touchstudy-core 0.1.86 → 0.1.88

package/dist/components/CkEditor/CkEditor.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface Props {
+    ref?: any;
+    value: string;
+    onChange: any;
+    option?: any;
+    disabled: boolean;
+}
+declare const CkEditor: ({ ref, value, onChange, option, disabled }: Props) => React.JSX.Element;
+export default CkEditor;

package/dist/components/CkEditor/config.d.ts

@@ -0,0 +1,19 @@
+export declare const config: {
+    height: number;
+    allowedContent: boolean;
+    toolbar: (string | string[] | {
+        name: string;
+        groups: string[];
+        items: string[];
+    } | {
+        name: string;
+        items: string[];
+        groups?: undefined;
+    } | {
+        name: string;
+        groups?: undefined;
+        items?: undefined;
+    })[];
+    filebrowserImageUploadUrl: string;
+    filebrowserUploadUrl: string;
+};

package/dist/components/ErrorHandler.d.ts

@@ -0,0 +1,6 @@
+import { FC } from "react";
+interface Props {
+    text: string;
+}
+declare const ErrorHandler: FC<Props>;
+export default ErrorHandler;

package/dist/components/LabelRequired.d.ts

@@ -0,0 +1,8 @@
+import { FormLabelProps } from "@mui/material";
+import { FC } from "react";
+interface Props extends FormLabelProps {
+    text: string;
+    isRequired?: boolean;
+}
+declare const LabelRequired: FC<Props>;
+export default LabelRequired;

package/dist/components/Selectors/ClassSelector.d.ts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+interface Props {
+    value?: any;
+    onChange: any;
+    externalClassIds?: number[];
+    title?: string;
+    disabled?: boolean;
+}
+declare const ClassSelector: FC<Props>;
+export default ClassSelector;

package/dist/components/Selectors/StudentSelector.d.ts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+interface Props {
+    value?: any;
+    onChange: any;
+    externalStudentIds?: number[];
+    title?: string;
+    disabled: boolean;
+}
+declare const StudentSelector: FC<Props>;
+export default StudentSelector;

package/dist/containers/Classes/apiClients/classService.d.ts

@@ -0,0 +1,16 @@
+import { ClassQuery, ClassRequestBody, LessonQuery, LessonRequestBody, StudentClassQuery } from "../configs/types";
+export declare const getListClassApi: (query: ClassQuery) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getStudentClassApi: (classId: number, query: StudentClassQuery) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getTeacherClassApi: (classId: number, query: StudentClassQuery) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getLessonClassApi: (classId: number, query: LessonQuery) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const createLessonClassApi: (classId: number, model: LessonRequestBody) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const updateLessonClassApi: (classId: number, lessonId: number, model: LessonRequestBody) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const deleteLessonClassApi: (classId: number, lessonId: number) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getClassByIdApi: (id: number) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const createClassApi: (model: ClassRequestBody) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const updateClassApi: (id: number, model: ClassRequestBody) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const deleteClassApi: (id: number) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const addStudentToClass: (id: number, studentIds: number[]) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const removeStudentFromClass: (id: number, studentId: number) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const addTeacherToClass: (id: number, teacherIds: number[]) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const removeTeacherFromClass: (id: number, teacherId: number) => Promise<import("axios").AxiosResponse<any, any>>;

package/dist/containers/Classes/apiClients/teacherService.d.ts

@@ -0,0 +1,2 @@
+import { TeacherQuery } from "../configs/types";
+export declare const getTeacherListApi: (query: TeacherQuery) => Promise<import("axios").AxiosResponse<any, any>>;

package/dist/containers/Classes/components/ClassForm.d.ts

@@ -0,0 +1,4 @@
+import { FC } from "react";
+import { ClassFormProps } from "../configs/interfaces";
+declare const ClassForm: FC<ClassFormProps>;
+export default ClassForm;

package/dist/containers/Classes/components/CorrectAnswerSelector.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+interface Props {
+    innerProps?: any;
+    answerCount: number;
+}
+declare const CorrectAnswerSelector: FC<Props>;
+export default CorrectAnswerSelector;

package/dist/containers/Classes/components/LessonFormBody.d.ts

@@ -0,0 +1,4 @@
+import { LessonFormProps } from "../configs/interfaces";
+import { FC } from "react";
+declare const LessonFormBody: FC<LessonFormProps>;
+export default LessonFormBody;

package/dist/containers/Classes/components/LessonFormDialog.d.ts

@@ -0,0 +1,14 @@
+import { LessonRequest, LessonResponse, TeacherSimpleResponse } from "../configs/types";
+import { FC } from "react";
+interface Props {
+    data?: LessonResponse;
+    open: boolean;
+    startDate?: any;
+    endDate?: any;
+    teachers: TeacherSimpleResponse[];
+    onSearchTeachers: (text: string) => void;
+    onClose: () => void;
+    onSubmit: (lesson: LessonRequest) => void;
+}
+declare const LessonFormDialog: FC<Props>;
+export default LessonFormDialog;

package/dist/containers/Classes/components/LessonList.d.ts

@@ -0,0 +1,27 @@
+import { LessonQuery, LessonRequest, LessonResponse, LessonSortBy, TeacherSimpleResponse } from "../configs/types";
+import { ChangeEvent, FC } from "react";
+import { DialogType } from "../hooks/useLessonClassList";
+import { PagingResponse } from "../../../utils/types/pagingResponse";
+interface Props {
+    openDialog?: DialogType;
+    paging: PagingResponse;
+    classList: LessonResponse[];
+    filter: LessonQuery;
+    startDate?: any;
+    endDate?: any;
+    t: any;
+    selectedLesson: LessonResponse | undefined;
+    teachers: TeacherSimpleResponse[];
+    disabled?: boolean;
+    onSearchTeachers: (text: string) => void;
+    handleOpenDeleteClassDialog: (value: LessonResponse) => void;
+    handleCloseConfirmDialog: () => void;
+    handleSort: (key: LessonSortBy) => void;
+    handleChangeSearchText: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleChangePage: (_: any, page: number) => void;
+    handleDeleteLessonClass: () => Promise<void>;
+    handleCreateOrUpdateLesson: (lesson: LessonRequest) => void;
+    handleOpenCreateOrUpdateDialog: (value?: LessonResponse) => void;
+}
+declare const LessonList: FC<Props>;
+export default LessonList;

package/dist/containers/Classes/components/SelectDialog.d.ts

@@ -0,0 +1,30 @@
+import { ChangeEvent, FC, RefObject } from "react";
+import { PagingResponse } from "../../../utils/types/pagingResponse";
+import React from "react";
+import { UserSortColumn } from "../../../utils/enums";
+import { UserSearchQuery } from "../../../utils/types/users";
+interface Props {
+    open: boolean;
+    title: string;
+    submitText: string;
+    onClose: () => void;
+    onSubmit: (userIds: number[]) => void;
+    isStudent: boolean;
+    paging: PagingResponse;
+    filter: UserSearchQuery;
+    selected: number[];
+    userList: any;
+    isCheckAll: (userList: any, userLength: number) => boolean;
+    isSelected: (id: number) => boolean;
+    numSelected: number;
+    textSearchRef: RefObject<HTMLInputElement>;
+    handleFetchUsers: () => void;
+    handleSort: (key: UserSortColumn) => void;
+    handleChangeSearchText: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleClickCheckbox: (event: React.MouseEvent<unknown>, id: number) => void;
+    handleChangePage: (_: any, page: number) => void;
+    handleClear: () => void;
+    handleSelectAllClick: (event: React.ChangeEvent<HTMLInputElement>, users: any) => void;
+}
+declare const SelectDialog: FC<Props>;
+export default SelectDialog;

package/dist/containers/Classes/components/StudentList.d.ts

@@ -0,0 +1,21 @@
+import { StudentClassQuery, StudentClassResponse, UserClassSortBy } from "../configs/types";
+import { ChangeEvent, FC, RefObject } from "react";
+import { PagingResponse } from "../../../utils/types/pagingResponse";
+interface Props {
+    onAdd?: Function;
+    paging: PagingResponse;
+    classList: StudentClassResponse[];
+    filter: StudentClassQuery;
+    t: any;
+    selectedStudent: StudentClassResponse | undefined;
+    textSearchRef: RefObject<HTMLInputElement> | null;
+    disabled?: boolean;
+    handleOpenDeleteClassDialog: (value: StudentClassResponse) => void;
+    handleCloseConfirmDialog: () => void;
+    handleSort: (key: UserClassSortBy) => void;
+    handleChangeSearchText: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleChangePage: (_: any, page: number) => void;
+    handleRemoveStudentFromClass: () => Promise<void>;
+}
+declare const StudentList: FC<Props>;
+export default StudentList;

package/dist/containers/Classes/components/TeacherList.d.ts

@@ -0,0 +1,21 @@
+import { StudentClassQuery, UserClassSortBy, TeacherClassResponse } from "../configs/types";
+import { ChangeEvent, FC, RefObject } from "react";
+import { PagingResponse } from "../../../utils/types/pagingResponse";
+interface Props {
+    onAdd?: Function;
+    paging: PagingResponse;
+    classList: TeacherClassResponse[];
+    filter: StudentClassQuery;
+    t: any;
+    selectedTeacher: TeacherClassResponse | undefined;
+    textSearchRef: RefObject<HTMLInputElement> | null;
+    disabled?: boolean;
+    handleOpenDeleteClassDialog: (value: TeacherClassResponse) => void;
+    handleCloseConfirmDialog: () => void;
+    handleSort: (key: UserClassSortBy) => void;
+    handleChangeSearchText: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleChangePage: (_: any, page: number) => void;
+    handleRemoveTeacherFromClass: () => Promise<void>;
+}
+declare const TeacherList: FC<Props>;
+export default TeacherList;

package/dist/containers/Classes/components/TeacherSelector.d.ts

@@ -0,0 +1,11 @@
+import { FC } from "react";
+import { Option, TeacherSimpleResponse } from "../configs/types";
+interface Props {
+    teachers: TeacherSimpleResponse[];
+    value?: number | null;
+    onChange: (val: Option | null) => void;
+    onInputChange: (inputText: string) => void;
+    isDisabled?: boolean;
+}
+declare const TeacherSelector: FC<Props>;
+export default TeacherSelector;

package/dist/containers/Classes/configs/constants.d.ts

@@ -0,0 +1,70 @@
+import * as yup from "yup";
+import { ClassHeaderTable, ClassQuery, ClassRequest, QuestionColumn, StudentClassQuery, DayOfWeek, LessonQuery, LessonClassHeaderTable, LessonRequest, TeacherQuery, UserClassHeaderTable } from "./types";
+import { UserSortColumn } from "../../../utils/enums";
+import { UserSearchQuery } from "../../../utils/types/users";
+export declare const CLASS_HEADERS: ClassHeaderTable[];
+export declare const USER_HEADERS: ({
+    title: string;
+    sortKey?: undefined;
+} | {
+    title: string;
+    sortKey: UserSortColumn;
+})[];
+export declare const DefaultClassFilter: ClassQuery;
+export declare const DefaultStudentClassFilter: StudentClassQuery;
+export declare const DefaultLessonFilter: LessonQuery;
+export declare const DefaultTeacherFilter: TeacherQuery;
+export declare const CLASS_QUESTIONS: number[];
+export declare const DEFAULT_CLASS_REQUEST: ClassRequest;
+export declare const DATE_TIME_FORMAT = "YYYY-MM-DDTHH:mm:ss";
+export declare const DEFAULT_LESSON_REQUEST: LessonRequest;
+export declare const ClassSchema: (t: any) => yup.ObjectSchema<{
+    name: string;
+    startDate: Date;
+    endDate: Date;
+    mainTeacherId: number;
+    courseWeeklyDays: {
+        dayOfWeek: any;
+        startTime: any;
+        endTime: any;
+    }[] | undefined;
+}, yup.AnyObject, {
+    name: undefined;
+    startDate: undefined;
+    endDate: undefined;
+    mainTeacherId: undefined;
+    courseWeeklyDays: "";
+}, "">;
+export declare const LessonSchema: (t: any) => yup.ObjectSchema<{
+    date: Date;
+    startTime: string;
+    endTime: string;
+    mainTeacherId: number;
+}, yup.AnyObject, {
+    date: undefined;
+    startTime: undefined;
+    endTime: undefined;
+    mainTeacherId: undefined;
+}, "">;
+export declare const QUESTION_HEADER_COLUMNS: QuestionColumn[];
+export declare const ANSWERS_COUNT: number[];
+export declare const MAX_ANSWERS_COUNT = 10;
+export declare const CLASS_INFORMATION_FORM = "CLASS_INFORMATION_FORM";
+export declare const STUDENT_CLASS_HEADERS: UserClassHeaderTable[];
+export declare const TEACHER_CLASS_HEADERS: UserClassHeaderTable[];
+export declare const LESSON_CLASS_HEADERS: LessonClassHeaderTable[];
+export declare const DayOfWeekOptions: (t: any) => {
+    label: any;
+    value: DayOfWeek;
+}[];
+export declare const dayOfWeekStrings: any;
+export declare const TabList: ({
+    label: string;
+    value: number;
+    key?: undefined;
+} | {
+    label: string;
+    key: string;
+    value: number;
+})[];
+export declare const DEFAULT_USER_FILTERS: UserSearchQuery;

package/dist/containers/Classes/configs/interfaces.d.ts

@@ -0,0 +1,23 @@
+import { FormikProps } from "formik";
+import { ClassRequest, LessonRequest, TeacherSimpleResponse } from "./types";
+export interface ClassFormProps {
+    id?: string;
+    history: any;
+    formikProp: FormikProps<ClassRequest>;
+    teachers: TeacherSimpleResponse[];
+    onSearchTeachers: (text: string) => void;
+    data?: ClassRequest;
+    disabled?: boolean;
+    classListUrl: string;
+}
+export interface LessonFormProps {
+    id?: number;
+    open: boolean;
+    formikProp: FormikProps<LessonRequest>;
+    startDate?: any;
+    endDate?: any;
+    data?: LessonRequest;
+    teachers: TeacherSimpleResponse[];
+    onSearchTeachers: (text: string) => void;
+    onClose: () => void;
+}

package/dist/containers/Classes/configs/types.d.ts

@@ -0,0 +1,215 @@
+export declare type ClassResponse = {
+    id?: number;
+    name: string;
+    startDate: string;
+    endDate: string;
+    totalStudents: number;
+    totalTeachers: number;
+    totalLessons: number;
+    mainTeacherId: number;
+    courseWeeklyDays: WeeklyDayResponse[];
+};
+export declare type StudentClassResponse = {
+    id?: number;
+    studentId: number;
+    studentName: string;
+    studentEmail: string;
+    studentPhoneNumber?: string;
+    roles: Array<string>;
+    paymentTime?: string;
+    createdAt?: string;
+    studentCreatedAt?: string;
+};
+export declare type TeacherClassResponse = {
+    teacherId: number;
+    teacherName: string;
+    roles: Array<string>;
+    teacherEmail: string;
+    teacherPhoneNumber?: string;
+    teacherCreatedAt?: string;
+};
+export declare type Question = {
+    id: number;
+    answerCount: number;
+    correctAnswers: number[];
+};
+export declare type QuestionResponse = {
+    id: number;
+    answerCount: number;
+    correctAnswers: string;
+};
+export declare enum ClassType {
+    Normal = "Normal",
+    Standard = "Standard"
+}
+export declare type ClassRequest = {
+    id?: number | string;
+    name: string;
+    startDate: moment.Moment | null;
+    endDate: moment.Moment | null;
+    mainTeacherId: number | null;
+    courseWeeklyDays: WeeklyDayRequest[];
+};
+export declare type ClassRequestBody = {
+    name: string;
+    startDate: string;
+    endDate: string;
+    mainTeacherId: number;
+    courseWeeklyDays: WeeklyDayRequestBody[];
+};
+export declare type WeeklyDayRequest = {
+    dayOfWeek: DayOfWeek;
+    startTime: moment.Moment | null;
+    endTime: moment.Moment | null;
+};
+export declare type WeeklyDayRequestBody = {
+    dayOfWeek: DayOfWeek;
+    startTime: string;
+    endTime: string;
+};
+export declare type WeeklyDayResponse = {
+    dayOfWeek: DayOfWeek;
+    startTime: string;
+    endTime: string;
+};
+export declare type LessonResponse = {
+    id: number;
+    startTime: string;
+    endTime: string;
+    mainTeacherId: number;
+    mainTeacherUserId: number;
+    mainTeacherName: string;
+    mainTeacherEmail: string;
+    date: string;
+    isCancelled: boolean;
+};
+export declare type LessonRequest = {
+    startTime: moment.Moment | null;
+    endTime: moment.Moment | null;
+    mainTeacherId: number | null;
+    date: moment.Moment | null;
+    isCancelled: boolean;
+};
+export declare type LessonRequestBody = {
+    startTime: string;
+    endTime: string;
+    mainTeacherId: number | null;
+    date: string;
+    isCancelled: boolean;
+};
+export declare enum DayOfWeek {
+    Sunday = 0,
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6
+}
+export declare type QuestionRequest = {
+    numberOfAnswers: number;
+    correctAnswers: number[];
+    score?: number;
+    categoryId?: number;
+    id?: number;
+    article?: number;
+};
+export declare type QuestionColumn = {
+    name: string;
+    width?: string | number;
+};
+export declare type ClassGenerateRequest = {
+    numberOfQuestions?: string;
+    numberOfArticles?: string;
+};
+export declare type ClassQuery = {
+    currentPage: number;
+    pageSize: number;
+    sortColumnName: ClassSortBy;
+    textSearch?: string;
+    sortColumnDirection: OrderBy;
+    statuses?: ClassStatus[];
+};
+export declare type StudentClassQuery = {
+    currentPage: number;
+    pageSize: number;
+    sortColumnName: UserClassSortBy;
+    textSearch?: string;
+    sortColumnDirection: OrderBy;
+    isInCourse?: boolean;
+};
+export declare type LessonQuery = {
+    currentPage: number;
+    pageSize: number;
+    sortColumnName: LessonSortBy;
+    textSearch: string;
+    sortColumnDirection: OrderBy;
+};
+export declare type TeacherQuery = {
+    currentPage: number;
+    pageSize: number;
+    sortColumnName: TeacherSortBy;
+    textSearch: string;
+    sortColumnDirection: OrderBy;
+};
+export declare enum TeacherSortBy {
+    Name = "UserProfile.FullName",
+    Email = "UserProfile.Email"
+}
+export declare enum ClassStatus {
+    Default = "Default",
+    Pending = "Pending",
+    Inprogress = "Inprogress",
+    Completed = "Completed"
+}
+export declare enum ClassStatusNumber {
+    Default = 0,
+    Pending = 1,
+    Inprogress = 2,
+    Completed = 3
+}
+export declare enum ClassSortBy {
+    CreatedAt = "CreatedAt",
+    EndDate = "EndDate",
+    Name = "Name",
+    StartDate = "StartDate"
+}
+export declare enum UserClassSortBy {
+    CreatedAt = "CreatedAt",
+    PhoneNumber = "PhoneNumber",
+    FullName = "FullName",
+    Email = "Email"
+}
+export declare enum LessonSortBy {
+    CreatedAt = "CreatedAt",
+    Date = "Date",
+    IsCancelled = "IsCancelled",
+    StartTime = "StartTime",
+    EndTime = "EndTime"
+}
+export declare enum OrderBy {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export declare type ClassHeaderTable = {
+    title: string;
+    sortKey?: ClassSortBy;
+};
+export declare type UserClassHeaderTable = {
+    title: string;
+    sortKey?: UserClassSortBy;
+};
+export declare type LessonClassHeaderTable = {
+    title: string;
+    sortKey?: LessonSortBy;
+};
+export declare type TeacherSimpleResponse = {
+    id: number;
+    teacherUserId: number;
+    teacherName: string;
+    teacherEmail: string;
+};
+export declare type Option = {
+    label: string;
+    value: number | string;
+};

package/dist/containers/Classes/hooks/useClassDetail.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="yup" />
+import { FormikHelpers } from "formik";
+import _ from "lodash";
+import { ChangeEvent } from "react";
+import { ClassResponse, StudentClassResponse, TeacherClassResponse, ClassRequest, LessonRequest } from "../configs/types";
+import { PagingResponse } from "../../../utils/types/pagingResponse";
+import { UserSortColumn } from "../../../utils/enums";
+declare type DialogOpenType = "Student" | "Teacher" | "Lesson";
+declare const useClassDetail: (history: any, id?: string | undefined) => {
+    id: string | undefined;
+    schema: import("yup").ObjectSchema<{
+        name: string;
+        startDate: Date;
+        endDate: Date;
+        mainTeacherId: number;
+        courseWeeklyDays: {
+            dayOfWeek: any;
+            startTime: any;
+            endTime: any;
+        }[] | undefined;
+    }, import("yup").AnyObject, {
+        name: undefined;
+        startDate: undefined;
+        endDate: undefined;
+        mainTeacherId: undefined;
+        courseWeeklyDays: "";
+    }, "">;
+    paging: PagingResponse;
+    filter: import("../../../utils/types/searchQuery").BaseSearchQuery<UserSortColumn>;
+    listUserSelected: number[];
+    isSelected: (id: number) => boolean;
+    textSearchRef: import("react").RefObject<HTMLInputElement>;
+    numSelected: number;
+    handleClickCheckbox: (_: React.MouseEvent<unknown>, id: number) => void;
+    handleChangePage: (_: any, page: number) => void;
+    handleClear: () => void;
+    handleSort: (key: UserSortColumn) => void;
+    handleChangeSearchText: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleSelectAllClick: (event: React.ChangeEvent<HTMLInputElement>, users: any) => void;
+    debounceSort: _.DebouncedFunc<(key: UserSortColumn) => void>;
+    isCheckAll: (userList: any, userLength: number) => boolean;
+    handleFetchUsers: () => void;
+    course: ClassResponse | undefined;
+    userList: StudentClassResponse[] | TeacherClassResponse[];
+    teacherOptions: import("../configs/types").TeacherSimpleResponse[];
+    studentListProps: {
+        paging: PagingResponse;
+        classList: StudentClassResponse[];
+        filter: import("../configs/types").StudentClassQuery;
+        selectedStudent: StudentClassResponse | undefined;
+        t: any;
+        textSearchRef: import("react").RefObject<HTMLInputElement>;
+        debounceSearch: _.DebouncedFunc<() => void>;
+        handleOpenDeleteClassDialog: (value: StudentClassResponse) => void;
+        handleCloseConfirmDialog: () => void;
+        handleSort: (key: import("../configs/types").UserClassSortBy) => void;
+        handleChangeSearchText: (e: ChangeEvent<HTMLInputElement>) => void;
+        handleChangePage: (_: any, page: number) => void;
+        handleRemoveStudentFromClass: () => Promise<void>;
+        resetData: () => void;
+    };
+    teacherListProps: {
+        paging: PagingResponse;
+        classList: TeacherClassResponse[];
+        filter: import("../configs/types").StudentClassQuery;
+        selectedTeacher: TeacherClassResponse | undefined;
+        t: any;
+        textSearchRef: import("react").RefObject<HTMLInputElement>;
+        debounceSearch: _.DebouncedFunc<() => void>;
+        handleOpenDeleteClassDialog: (value: TeacherClassResponse) => void;
+        handleCloseConfirmDialog: () => void;
+        handleSort: (key: import("../configs/types").UserClassSortBy) => void;
+        handleChangeSearchText: (e: ChangeEvent<HTMLInputElement>) => void;
+        handleChangePage: (_: any, page: number) => void;
+        handleRemoveTeacherFromClass: () => Promise<void>;
+        resetData: () => void;
+    };
+    lessonListProps: {
+        paging: PagingResponse;
+        classList: import("../configs/types").LessonResponse[];
+        filter: import("../configs/types").LessonQuery;
+        selectedLesson: import("../configs/types").LessonResponse | undefined;
+        openDialog: "Update" | "Create" | "Remove" | undefined;
+        t: any;
+        handleOpenCreateOrUpdateDialog: (value?: import("../configs/types").LessonResponse | undefined) => void;
+        handleOpenDeleteClassDialog: (value: import("../configs/types").LessonResponse) => void;
+        handleCloseConfirmDialog: () => void;
+        handleSort: (key: import("../configs/types").LessonSortBy) => void;
+        handleChangeSearchText: (e: ChangeEvent<HTMLInputElement>) => void;
+        handleChangePage: (_: any, page: number) => void;
+    };
+    openSelectDialog: "Student" | "Teacher" | "Lesson" | undefined;
+    classRequest: ClassRequest | undefined;
+    handleChangeTextSearchTeachers: (text: string) => void;
+    handleCloseSelectDialog: () => void;
+    handleSubmit: (values: ClassRequest, _: FormikHelpers<ClassRequest>) => Promise<void>;
+    handleOpenSelectDialog: (type: DialogOpenType) => void;
+    handleAddToClass: (userIds: number[]) => Promise<void>;
+    handleDeleteLessonClass: () => Promise<void>;
+    handleCreateOrUpdateLesson: (lesson: LessonRequest) => Promise<void>;
+    getStudents: () => Promise<void>;
+    getLessons: () => Promise<void>;
+    getTeachers: () => Promise<void>;
+};
+export default useClassDetail;