touchstudy-core 0.1.185 → 0.1.187

package/dist/components/Questions/configs/fns.d.ts

@@ -1,6 +1,6 @@
 import { QuestionGroupRequest } from "../../../utils/types";
 export declare const isSequentialQuestionGroups: (questionGroups: QuestionGroupRequest[]) => boolean;
-export declare const getQuestionGroupsAfterQuestionCountChanged: (questionGroups: QuestionGroupRequest[], questionCount: number, index: number, checkSequential?: boolean | undefined) => QuestionGroupRequest[] | undefined;
+export declare const getQuestionGroupsAfterQuestionCountChanged: (questionGroups: QuestionGroupRequest[], questionCount: number, index: number, checkSequential?: boolean | undefined) => QuestionGroupRequest[];
 export declare const getPreviousQuestinGroupCategory: (values: any, key: string, paths: number[]) => any;
 export declare const generateNewQuestionGroup: (questionGroups: QuestionGroupRequest[], isMath: boolean) => QuestionGroupRequest;
 export declare const reduceToMathArticles: (data: any, isMath?: number | undefined) => any;

package/dist/containers/ExamResult/apiClients/index.d.ts

@@ -14,3 +14,9 @@ export declare const getResultsEffectSizeTeacher: (id: number, studentId: number
 export declare const getResultsTimeOrderQuestionTeacher: (id: number, studentId: number) => Promise<import("axios").AxiosResponse<any, any>>;
 export declare const getResultsCategoriesTeacher: (id: number, studentId: number) => Promise<import("axios").AxiosResponse<any, any>>;
 export declare const createConversationApi: (data: any) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getOverallResultsApi: (code: string) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getOverallResultsTeacherApi: (id: number, studentId: number) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getOverallCategoriesResultsApi: (code: string) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getOverallCategoriesResultsTeacherApi: (id: number, studentId: number) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getQuestionTimeCategoriesResultsApi: (code: string) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const getQuestionTimeCategoriesResultsTeacherApi: (id: number, studentId: number) => Promise<import("axios").AxiosResponse<any, any>>;

package/dist/containers/ExamResult/components/Charts/HexagonChart.d.ts

@@ -5,6 +5,10 @@ interface Props {
     avgData: number[];
     categories: string[];
     height?: number;
+    isPrint?: boolean;
+    customTooltip?: (val: any) => string;
+    xAxisLabelFormatter?: (val: string, option: any) => string;
+    onRendered?: () => void;
 }
 declare const HexagonChart: FC<Props>;
 export default HexagonChart;

package/dist/containers/ExamResult/components/Charts/SolutionOrderChart.d.ts

@@ -0,0 +1,11 @@
+import { FC } from 'react';
+export interface SolutionOrderChartProps {
+    series: any;
+    chartOptions: any;
+    dataChartIndex: number;
+    totalCharts: number;
+    onPrevChartClick: () => void;
+    onNextChartClick: () => void;
+}
+declare const SolutionOrderChart: FC<SolutionOrderChartProps>;
+export default SolutionOrderChart;

package/dist/containers/ExamResult/components/Charts/TimeChart.d.ts

@@ -4,6 +4,10 @@ interface Props {
     avgTimes: number[];
     categories: number[];
     height?: number;
+    isPrint?: boolean;
+    xTooltipLabelFormatter?: (val: string, option: any) => string;
+    yTooltipLabelFormatter?: (val: string, option: any) => string;
+    onRendered?: () => void;
 }
 declare const TimeChart: FC<Props>;
 export default TimeChart;

package/dist/containers/ExamResult/components/Charts/TimeOrderChart.d.ts

@@ -4,6 +4,7 @@ interface Props {
     timelyOrderQuestion: TimelyOrderQuestion;
     options: any;
     series: any;
+    shink: boolean;
     setIsRendered: (questionGroupIndex: number) => void;
 }
 declare const TimeOrderChart: FC<Props>;

package/dist/containers/ExamResult/components/Charts/index.d.ts

@@ -1,4 +1,5 @@
 import HexagonChart from "./HexagonChart";
+import SolutionOrderChart from "./SolutionOrderChart";
 import TimeChart from "./TimeChart";
 import TimeOrderChart from "./TimeOrderChart";
-export { HexagonChart, TimeChart, TimeOrderChart };
+export { HexagonChart, TimeChart, TimeOrderChart, SolutionOrderChart };

package/dist/containers/ExamResult/components/CompareGrass/AnswerPopover.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+interface AnswerPopoverProps {
+    anchorEl: HTMLElement | null;
+    onClose: () => void;
+    open: boolean;
+}
+declare const AnswerPopover: React.FC<AnswerPopoverProps>;
+export default AnswerPopover;

package/dist/containers/ExamResult/components/CompareGrass/index.d.ts

@@ -1,7 +1,10 @@
 import { FC } from "react";
 import { EffectSize } from "../../configs/types";
+import { ExamResult } from "../../../../utils";
 interface Props {
     effectSize: EffectSize[];
+    data?: ExamResult;
+    isPrint?: boolean;
 }
 declare const CompareGrass: FC<Props>;
 export default CompareGrass;

package/dist/containers/ExamResult/components/ExamHeader.d.ts

@@ -7,7 +7,7 @@ interface Props {
     courses?: string;
     onCreateQA?: (e: MouseEvent<HTMLButtonElement>) => void;
     onViewQA?: () => void;
-    onPrint: () => void;
+    onPrint?: () => void;
 }
 declare const ExamHeader: FC<Props>;
 export default ExamHeader;

package/dist/containers/ExamResult/components/GradesByTerritoryProblems.d.ts

@@ -0,0 +1,9 @@
+import { FC } from "react";
+import { ProblemContainerProps } from "./ProblemContainer";
+import { CategoryResponse } from "../../../utils";
+interface Props extends Omit<ProblemContainerProps, "title" | "keyOpen"> {
+    data: CategoryResponse[];
+    isPrint?: boolean;
+}
+declare const GradesByTerritoryProblems: FC<Props>;
+export default GradesByTerritoryProblems;

package/dist/containers/ExamResult/components/MyAnswer/configs/interfaces.d.ts

@@ -1,12 +1,13 @@
 import { Action } from "../../../../../components/Tooltips/configs/types";
 import { Question } from "../../../../../utils";
-import { StudentQuestionResult } from "../../../configs/types";
+import { EffectSize, StudentQuestionResult } from "../../../configs/types";
 export interface AnswerItemProps extends AnswerItemBaseProps {
     data: Question;
     openContextMenu: boolean;
     nextData?: Question;
     isLast?: boolean;
     isFirst?: boolean;
+    effectSize?: EffectSize;
 }
 export interface TextbookAnswerItemProps extends TextbookAnswerItemBaseProps {
     data: StudentQuestionResult;

package/dist/containers/ExamResult/components/MyAnswer/index.d.ts

@@ -1,12 +1,14 @@
 import { FC } from "react";
 import { CategoryResponse, ExamResult } from "../../../../utils/types/examResults";
 import { AnswerItemBaseProps } from "./configs/interfaces";
+import { EffectSize } from "../../configs/types";
 interface Props {
     data: ExamResult;
     questionIdContextMenu?: number;
     categories: CategoryResponse[];
     itemProps?: AnswerItemBaseProps;
     isStudent: boolean;
+    effectSize: EffectSize[];
 }
 declare const MyAnswer: FC<Props>;
 export default MyAnswer;

package/dist/containers/ExamResult/components/OverallTabs/CategoriesOverallChartContainer.d.ts

@@ -0,0 +1,13 @@
+import { FC } from "react";
+export interface CategoriesOverallChartContainerProps {
+    isLoading: boolean;
+    myData: number[];
+    avgData: number[];
+    shortCategories: string[];
+    isPrint?: boolean;
+    formatTooltip: (val: any) => string;
+    xAxisLabelFormatter: (val: string, option: any) => string;
+    onRendered?: () => void;
+}
+declare const CategoriesOverallChartContainer: FC<CategoriesOverallChartContainerProps>;
+export default CategoriesOverallChartContainer;

package/dist/containers/ExamResult/components/OverallTabs/OverallChartContainer.d.ts

@@ -0,0 +1,13 @@
+import { FC } from "react";
+export interface OverallChartContainerProps {
+    isLoading: boolean;
+    myData: number[];
+    avgData: number[];
+    shortCategories: string[];
+    isPrint?: boolean;
+    formatTooltip: (val: any) => string;
+    xAxisLabelFormatter: (val: string, option: any) => string;
+    onRendered?: () => void;
+}
+declare const OverallChartContainer: FC<OverallChartContainerProps>;
+export default OverallChartContainer;

package/dist/containers/ExamResult/components/OverallTabs/OverallTab.d.ts

@@ -1,5 +1,13 @@
 import { FC } from "react";
+import { OverallChartContainerProps } from "./OverallChartContainer";
+import { CategoriesOverallChartContainerProps } from "./CategoriesOverallChartContainer";
+import { OverallTimeChartContainerProps } from "./OverallTimeChartContainer";
 interface Props {
+    overallChartContainerProps: OverallChartContainerProps;
+    categoriesOverallChartContainerProps: CategoriesOverallChartContainerProps;
+    overallTimeChartContainerProps: OverallTimeChartContainerProps;
+    isPrint?: boolean;
+    onRendered?: () => void;
 }
 declare const OverallTab: FC<Props>;
 export default OverallTab;

package/dist/containers/ExamResult/components/OverallTabs/OverallTabHeader.d.ts

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

package/dist/containers/ExamResult/components/OverallTabs/OverallTimeChart.d.ts

@@ -0,0 +1,11 @@
+import { FC } from "react";
+import { QuestionTimeCategoryData } from "../../configs/types";
+interface Props {
+    data: QuestionTimeCategoryData;
+    total: number;
+    index: number;
+    isPrint?: boolean;
+    onRendered?: (index: number) => void;
+}
+declare const OverallTimeChart: FC<Props>;
+export default OverallTimeChart;

package/dist/containers/ExamResult/components/OverallTabs/OverallTimeChartContainer.d.ts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+import { QuestionTimeCategoryData } from "../../configs/types";
+export interface OverallTimeChartContainerProps {
+    isLoading: boolean;
+    categories: QuestionTimeCategoryData[];
+    isPrint?: boolean;
+    onRendered?: () => void;
+}
+declare const OverallTimeChartContainer: FC<OverallTimeChartContainerProps>;
+export default OverallTimeChartContainer;

package/dist/containers/ExamResult/components/PrintSolutionOrder.d.ts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+import { TimelyOrderQuestion } from "../configs/types";
+interface Props {
+    timelyOrderQuestions: TimelyOrderQuestion[];
+    allChartOptions: any;
+    allSeries: any;
+    setIsRendered: (questionGroupIndex: number) => void;
+}
+declare const PrintSolutionOrder: FC<Props>;
+export default PrintSolutionOrder;

package/dist/containers/ExamResult/components/PrintSolutionOrderItem.d.ts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+import { TimelyOrderQuestion } from "../configs/types";
+interface Props {
+    timelyOrderQuestion: TimelyOrderQuestion;
+    options: any;
+    series: any;
+    setIsRendered: (questionGroupIndex: number) => void;
+}
+declare const PrintSolutionOrderItem: FC<Props>;
+export default PrintSolutionOrderItem;

package/dist/containers/ExamResult/components/ProblemContainer.d.ts

@@ -0,0 +1,12 @@
+import { FC, PropsWithChildren } from "react";
+import { ProblemKey } from "../configs/types";
+export interface ProblemContainerProps extends PropsWithChildren {
+    title: string;
+    detail?: string;
+    keyOpen: ProblemKey;
+    openProblem?: ProblemKey;
+    isPrint?: boolean;
+    changeOpen?: (key?: ProblemKey) => void;
+}
+declare const ProblemContainer: FC<ProblemContainerProps>;
+export default ProblemContainer;

package/dist/containers/ExamResult/components/ProtractedProblem/index.d.ts

@@ -1,13 +1,10 @@
 import { FC } from "react";
 import { LongTimeSpendQuestion, ProblemKey } from "../../configs/types";
-import { ExamResult } from "../../../../utils";
 interface Props {
     data: LongTimeSpendQuestion[];
     keyOpen: ProblemKey;
-    examResult?: ExamResult;
     openProblem?: ProblemKey;
     changeOpen?: (key?: ProblemKey) => void;
-    isMyStoryStudent?: boolean;
 }
 declare const ProtractedProblem: FC<Props>;
 export default ProtractedProblem;

package/dist/containers/ExamResult/components/ProtractedProblems.d.ts

@@ -0,0 +1,9 @@
+import { FC } from "react";
+import { ProblemContainerProps } from "./ProblemContainer";
+import { LongTimeSpendQuestion } from "../configs/types";
+interface Props extends Omit<ProblemContainerProps, "title" | "keyOpen"> {
+    data: LongTimeSpendQuestion[];
+    isPrint?: boolean;
+}
+declare const ProtractedProblems: FC<Props>;
+export default ProtractedProblems;

package/dist/containers/ExamResult/components/SolutionOrder.d.ts

@@ -0,0 +1,8 @@
+import { FC } from "react";
+import { SolutionOrderChartProps } from "./Charts/SolutionOrderChart";
+import { ProblemContainerProps } from "./ProblemContainer";
+interface Props extends SolutionOrderChartProps, Omit<ProblemContainerProps, "title" | "keyOpen"> {
+    isPrint?: boolean;
+}
+declare const SolutionOrder: FC<Props>;
+export default SolutionOrder;

package/dist/containers/ExamResult/components/TrickyProblems.d.ts

@@ -0,0 +1,9 @@
+import { FC } from "react";
+import { ProblemContainerProps } from "./ProblemContainer";
+import { Question } from "../../../utils/types/examResults";
+interface Props extends Omit<ProblemContainerProps, "title" | "keyOpen"> {
+    data: Question[];
+    isPrint?: boolean;
+}
+declare const TrickyProblems: FC<Props>;
+export default TrickyProblems;

package/dist/containers/ExamResult/components/Vulnerable/index.d.ts

@@ -1,12 +1,12 @@
 import { FC } from "react";
 import { ProblemKey } from "../../configs/types";
-import { ExamResult } from "../../../../utils/types/examResults";
+import { CategoryResponse, ExamResult } from "../../../../utils/types/examResults";
 interface Props {
     keyOpen: ProblemKey;
     data: ExamResult;
     openProblem?: ProblemKey;
+    categories: CategoryResponse[];
     changeOpen?: (key?: ProblemKey) => void;
-    isMyStoryStudent?: boolean;
 }
 declare const Vulnerable: FC<Props>;
 export default Vulnerable;

package/dist/containers/ExamResult/components/VulnerableProblems.d.ts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+import { ProblemContainerProps } from "./ProblemContainer";
+import { CategoryResponse, Question } from "../../../utils/types/examResults";
+interface Props extends Omit<ProblemContainerProps, "title" | "keyOpen"> {
+    data: Question[];
+    categories: CategoryResponse[];
+    isPrint?: boolean;
+}
+declare const VulnerableProblems: FC<Props>;
+export default VulnerableProblems;

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

@@ -5,6 +5,10 @@ export declare const TabList: {
     label: string;
     value: number;
 }[];
+export declare const TextbookTabList: {
+    label: string;
+    value: number;
+}[];
 export declare enum Roles {
     Student = "Student",
     Teacher = "Teacher",
@@ -85,3 +89,168 @@ export declare const defaultSeries: (t: any) => {
     name: any;
     data: never[];
 }[];
+export declare const DEFAULT_HEXAGON_OPTIONS: {
+    chart: {
+        height: number;
+        type: string;
+        toolbar: {
+            show: boolean;
+        };
+        dropShadow: {
+            enabled: boolean;
+            blur: number;
+            left: number;
+            top: number;
+        };
+    };
+    tooltip: {
+        enable: boolean;
+        custom: ({ series, seriesIndex, dataPointIndex, w }: any) => string;
+    };
+    plotOptions: {
+        radar: {
+            polygons: {
+                strokeWidth: number;
+                strokeColors: string;
+                connectorColors: string;
+            };
+        };
+    };
+    title: {
+        show: boolean;
+    };
+    stroke: {
+        width: number;
+    };
+    fill: {
+        opacity: number;
+    };
+    markers: {
+        size: number;
+        hover: {
+            size: number;
+        };
+        strokeColors: string;
+    };
+    yaxis: {
+        show: boolean;
+        min: number;
+        max: number;
+        tickAmount: number;
+    };
+    xaxis: {
+        categories: never[];
+        labels: {
+            style: {
+                fontSize: string;
+                fontFamily: string;
+                colors: string[];
+            };
+            formatter: (val: string) => string;
+        };
+    };
+    colors: string[];
+    legend: {
+        show: boolean;
+        markers: {
+            width: number;
+            height: number;
+            radius: number;
+            customHTML: undefined;
+        };
+        labels: {
+            useSeriesColors: boolean;
+            fontSize: string;
+            fontWeight: number;
+        };
+    };
+};
+export declare const DEFAULT_TIME_CHART_OPTIONS: {
+    chart: {
+        height: number;
+        type: string;
+        toolbar: {
+            show: boolean;
+        };
+        zoom: {
+            enabled: boolean;
+        };
+    };
+    grid: {
+        show: boolean;
+    };
+    stroke: {
+        width: number;
+    };
+    markers: {
+        size: number[];
+        colors: string;
+        strokeWidth: number;
+        strokeColors: string[];
+        hover: {
+            size: number;
+        };
+    };
+    colors: string[];
+    legend: {
+        show: boolean;
+        itemMargin: {
+            vertical: string;
+        };
+        markers: {
+            width: number;
+            height: number;
+            radius: number;
+            customHTML: undefined;
+        };
+        labels: {
+            useSeriesColors: boolean;
+            colors: string[];
+            fontSize: string;
+            fontWeight: number;
+        };
+    };
+    xaxis: {
+        categories: never[];
+        axisBorder: {
+            show: boolean;
+            color: string;
+        };
+        axisTicks: {
+            show: boolean;
+            color: string;
+            height: number;
+        };
+    };
+    yaxis: {
+        max: number;
+        min: number;
+        tickAmount: number;
+        forceNiceScale: boolean;
+        axisBorder: {
+            show: boolean;
+            color: string;
+            width: number;
+            offsetX: number;
+        };
+        axisTicks: {
+            show: boolean;
+            color: string;
+            width: number;
+            offsetX: number;
+        };
+        labels: {
+            formatter: (value: any) => any;
+        };
+    };
+    tooltip: {
+        shared: boolean;
+        intersect: boolean;
+        y: {
+            formatter: (y: any) => any;
+        };
+        x: {
+            formatter: (x: any) => any;
+        };
+    };
+};

package/dist/containers/ExamResult/configs/functions.d.ts

@@ -3,3 +3,4 @@ export declare const toNumberOrder: (value: number) => string;
 export declare const formatDuration: (t: any, duration: number) => any;
 export declare const formatQuestionOrder: (index: number, t: any, language?: string | undefined) => any;
 export declare const groupMonth: (exams: ExamSessionResponse[]) => {} | undefined;
+export declare const normalizeArray: <T>(arr: T[], length: number, replacement: any) => (T | null)[];

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

@@ -1,5 +1,5 @@
 import { QuestionAnswerType } from './../../../utils/enums/examStatus';
-import { CategoryResponse } from "../../../utils/types/examResults";
+import { CategoryResponse, Question } from "../../../utils/types/examResults";
 import { Role } from '../../../utils';
 export interface CategoryFormat extends CategoryResponse {
     totalSolveTime: number;
@@ -36,10 +36,11 @@ export declare type LongTimeSpendQuestion = {
     topDuration?: any;
 };
 export declare enum ProblemKey {
-    TrickyProblem = 0,
-    ProtractedProblem = 1,
-    GradesByTerritory = 2,
-    Vulnerable = 3
+    SolutionOrder = 0,
+    TrickyProblem = 1,
+    ProtractedProblem = 2,
+    GradesByTerritory = 3,
+    Vulnerable = 4
 }
 export declare type TextbookResult = {
     id: number;
@@ -53,26 +54,9 @@ export declare type TextbookResult = {
     studentTextbookSessionId: number;
     studentQuestionResults: StudentQuestionResult[];
 };
-export declare type StudentQuestionResult = {
-    id: number;
-    questionGroupId: number;
-    selectedAnswers?: number[] | string;
-    correctAnswers?: number[] | string;
-    textualAnswers?: string[];
-    correctTextualAnswers?: string[];
-    isStar: boolean;
-    duration: number;
-    classAverageTime: number;
-    topDuration: number | null;
-    answerResponseSignal: number;
-    isCorrect: boolean;
-    answerTime: string;
-    questionGroupIndex: number;
-    score: number;
-    questionAnswerType: QuestionAnswerType;
+export declare type StudentQuestionResult = Question & {
     categories: Category[];
-    overallCorrectRate: number;
-    questionOrder: number;
+    questionGroupId: number;
 };
 export declare type Category = {
     parentCategoryId: number | null;
@@ -124,3 +108,35 @@ export declare type ExamSessionResponse = {
 export declare type GroupedExamSession = {
     [key: string]: ExamSessionResponse[];
 };
+export declare type OverallExamResultResponse = {
+    data: OverallExamResultData[];
+    maxData: OverallExamResultData;
+};
+export declare type OverallExamResultData = {
+    correctRate: number;
+    highLevelQuestions: number;
+    lowLevelQuestions: number;
+    totalAsteriskQuestions: number;
+    problemSolvingTime: number;
+    questionLongestTime: number;
+};
+export declare type OverallCategoryData = {
+    categoryId: number;
+    categoryName: string;
+    path: string;
+    totalCorrectQuestions: number;
+    avgCorrectQuestions: number;
+    totalQuestions: number;
+};
+export declare type QuestionTimeCategoryData = {
+    categoryId: number;
+    categoryName: string;
+    path: string;
+    questions: QuestionTime[];
+};
+export declare type QuestionTime = {
+    questionId: number;
+    questionOrder: number;
+    time: number;
+    avgTime: number;
+};

package/dist/containers/ExamResult/hooks/useCategoriesOverallChartContainer.d.ts

@@ -0,0 +1,9 @@
+declare const useCategoriesOverallChartContainer: (isStudent: boolean, examCode: string, code: string, examSessionId: number, chapterId: number, studentId: number) => {
+    isLoading: boolean;
+    myData: number[];
+    avgData: number[];
+    shortCategories: string[];
+    xAxisLabelFormatter: (_: string, { dataPointIndex }: any) => string;
+    formatTooltip: ({ dataPointIndex, w }: any) => string;
+};
+export default useCategoriesOverallChartContainer;

package/dist/containers/ExamResult/hooks/useExamResult.d.ts

@@ -4,6 +4,11 @@ import { MouseEvent } from "react";
 import { NoteResponse } from "../../../utils/types/note";
 declare const useExamResult: (props: ExamResultV2Props) => {
     t: any;
+    code: string | undefined;
+    examCode: string;
+    studentId: number;
+    examSessionId: number;
+    chapterId: number | undefined;
     fileName: string;
     selected: number;
     isStudent: any;
@@ -14,6 +19,7 @@ declare const useExamResult: (props: ExamResultV2Props) => {
         setRenderedChart: (chart: number) => void;
         handlePrintPdf: () => void;
         reset: () => void;
+        handleOverallChartsRendered: () => void;
     };
     examResultNotes: {
         selectedNote: NoteResponse | undefined;

package/dist/containers/ExamResult/hooks/useOverallChartContainer.d.ts

@@ -0,0 +1,9 @@
+declare const useOverallChartContainer: (isStudent: boolean, examCode: string, code: string, examSessionId: number, chapterId: number, studentId: number) => {
+    isLoading: boolean;
+    myData: number[];
+    avgData: number[];
+    shortCategories: string[];
+    xAxisLabelFormatter: (_: string, { dataPointIndex }: any) => any;
+    formatTooltip: ({ dataPointIndex, w }: any) => string;
+};
+export default useOverallChartContainer;

package/dist/containers/ExamResult/hooks/useOverallTimeChartContainer.d.ts

@@ -0,0 +1,6 @@
+import { QuestionTimeCategoryData } from "../configs/types";
+declare const useOverallTimeChartContainer: (isStudent: boolean, examCode: string, code: string, examSessionId: number, chapterId: number, studentId: number) => {
+    isLoading: boolean;
+    categories: QuestionTimeCategoryData[];
+};
+export default useOverallTimeChartContainer;