import { ScoresOverTimeMetaData, StudentAssessmentScoresOverTime } from "../types/student";
import { Categories } from "./Preprocessor";
export declare enum ScoreTypeE {
    LEAKY = "leakyScores",
    SCORES = "scores"
}
export declare const FlatCategoriesToCategoriesMap: {
    [key: string]: keyof StudentAssessmentScoresOverTime[""] | "Composite";
};
export type DifferenceIn = 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
export type ScoresCIResultsMapped = {
    [key in Categories | "Composite"]: {
        average: number[];
        std: number[];
        n: number[];
        ci?: number[][];
    };
};
export type ExportType = "scores" | "ci";
export declare enum XAxisLabelEnum {
    TITLES = "titles",
    CREATED_ATS = "created_ats"
}
interface ScoresCIResultsWithDates {
    dates: string[];
}
export type ScoresCIResults = ScoresCIResultsMapped & ScoresCIResultsWithDates;
export type CategoryScoresObj = {
    scores: number[];
    averages?: number[];
    stds?: number[];
    cis?: number[][];
    leakyScores?: number[];
};
export default class Data {
    private data;
    private metadata;
    dates: string[];
    dataEntrySessionCreatedAts: string[];
    dataEntrySessionTitles: string[];
    conditionalsScores: CategoryScoresObj;
    operatorsScores: CategoryScoresObj;
    syncAndMessagesScores: CategoryScoresObj;
    algorithmsCompoScores: CategoryScoresObj;
    algorithmsDeadCodePenaltyScores: CategoryScoresObj;
    commentsScores: CategoryScoresObj;
    debuggingScores: CategoryScoresObj;
    namingScores: CategoryScoresObj;
    analysisCompoScores: CategoryScoresObj;
    analysisDeadCodePenaltyScores: CategoryScoresObj;
    functionsScores: CategoryScoresObj;
    sequencingScores: CategoryScoresObj;
    parallelismScores: CategoryScoresObj;
    decompositionCompoScores: CategoryScoresObj;
    dataTypesScores: CategoryScoresObj;
    variablesAndDataStructScores: CategoryScoresObj;
    loopsScores: CategoryScoresObj;
    patternRecAndDataRepPenaltyScores: CategoryScoresObj;
    patternRecAndDataRepCompoScores: CategoryScoresObj;
    functionReuseScores: CategoryScoresObj;
    functionWithArgsScores: CategoryScoresObj;
    variablesInsteadOfLiteralsScores: CategoryScoresObj;
    generalisationAndAbstrCompoScores: CategoryScoresObj;
    compositeScores: CategoryScoresObj;
    isSorted: boolean;
    isNormalised: boolean;
    constructor(rawData: StudentAssessmentScoresOverTime, metadata: ScoresOverTimeMetaData);
    private init;
    penaliseScores(): void;
    categoryNamesMap(): {
        [key in Categories | "Composite"]: CategoryScoresObj;
    };
    sort(): void;
    calculateMovingStdBasedOnDataPoints(windowSize: number): void;
    calculateMovingStdBasedOnDates(windowSize: number, differenceIn?: DifferenceIn): void;
    calculateMovingStdBasedOnSessionMeta(plotXAxisLabelType: XAxisLabelEnum): void;
    calculateMovingAvgBasedOnSessionMeta(plotXAxisLabelType: XAxisLabelEnum): void;
    calculateMovingAverageBasedOnDataPoints(windowSize: number): void;
    calculateMovingAverageBasedOnDates(windowSize: number, differenceIn?: DifferenceIn): void;
    calculateMovingConfidenceIntervals(windowSize: number, basedOn: 'dataPoints' | 'dates' | 'sessions', differenceIn?: DifferenceIn, sessionsXaxisLabels?: XAxisLabelEnum): void;
    normaliseScores(): void;
    normaliseLeakyScores(): void;
    calculateMovingMaxBasedOnDates(windowSize: number, differenceIn?: DifferenceIn): void;
    calculateMovingMaxBasedOnSessions(plotXAxisLabelType: XAxisLabelEnum): void;
    calculateLeakyIntegrator(decreaseFactor: number, increaseFactor: number, lowerBoundDecreaseFactor: number, lowerBoundIncreaseFactor: number, upperBoundDecreaseFactor: number, upperBoundIncreaseFactor: number): void;
    getMovingAverageAndStdBasedOnDataPoints(windowSize: number): ScoresCIResults;
    getMovingAverageAndStdBasedOnDates(windowSize: number, differenceIn?: DifferenceIn): ScoresCIResults;
    getMovingAverageAndStdBasedOnSessions(plotXAxisLabelType: XAxisLabelEnum): {
        dates: string[];
        "Algorithms Composite Score": {
            average: number[];
            std: number[];
            n: number[];
        };
        "Algorithms Dead Code Penalty": {
            average: number[];
            std: number[];
            n: number[];
        };
        "Analysis Composite Score": {
            average: number[];
            std: number[];
            n: number[];
        };
        "Analysis Dead Code Penalty": {
            average: number[];
            std: number[];
            n: number[];
        };
        Conditionals: {
            average: number[];
            std: number[];
            n: number[];
        };
        Comments: {
            average: number[];
            std: number[];
            n: number[];
        };
        "Data Types": {
            average: number[];
            std: number[];
            n: number[];
        };
        "Decomposition Composite Score": {
            average: number[];
            std: number[];
            n: number[];
        };
        Debugging: {
            average: number[];
            std: number[];
            n: number[];
        };
        "Pattern Recognition and Data Representation Repetition Penalty": {
            average: number[];
            std: number[];
            n: number[];
        };
        Sequencing: {
            average: number[];
            std: number[];
            n: number[];
        };
        "Function Reuse": {
            average: number[];
            std: number[];
            n: number[];
        };
        "Functions with Arguments": {
            average: number[];
            std: number[];
            n: number[];
        };
        Functions: {
            average: number[];
            std: number[];
            n: number[];
        };
        "Generalisation and Abstraction Composite Score": {
            average: number[];
            std: number[];
            n: number[];
        };
        Parallelism: {
            average: number[];
            std: number[];
            n: number[];
        };
        Loops: {
            average: number[];
            std: number[];
            n: number[];
        };
        Naming: {
            average: number[];
            std: number[];
            n: number[];
        };
        Operators: {
            average: number[];
            std: number[];
            n: number[];
        };
        "Pattern Recognition and Data Representation Composite Score": {
            average: number[];
            std: number[];
            n: number[];
        };
        "Synchronization and Messages": {
            average: number[];
            std: number[];
            n: number[];
        };
        "Variables and Data Structures": {
            average: number[];
            std: number[];
            n: number[];
        };
        "Variables Instead of Literals": {
            average: number[];
            std: number[];
            n: number[];
        };
        Composite: {
            average: number[];
            std: number[];
            n: number[];
        };
    };
    calculateCompositeScores(scoreType: ScoreTypeE, withPenatly: boolean): void;
    calculateCompositeScoreOverTime(scoreType: ScoreTypeE): void;
    calculateAverageGivenTimeWindow(windowSize: number, halfLife: number | "automatic", differenceIn?: DifferenceIn): void;
    exportToLineGraphData(categories: Categories[], type: ExportType): ({
        x: string[];
        y: number[];
        name: string;
        legendgroup: keyof import("@robotical/automatic-assessments").Scores | "Composite";
        hoverinfo: string;
        text: string[];
        type: string;
        mode: string;
        fillcolor?: undefined;
        line?: undefined;
        fill?: undefined;
    } | {
        x: string[];
        y: number[] | undefined;
        name: string;
        type: string;
        mode: string;
        fillcolor: string;
        line: {
            color: string;
        };
        legendgroup?: undefined;
        hoverinfo?: undefined;
        text?: undefined;
        fill?: undefined;
    } | {
        x: string[];
        y: number[] | undefined;
        name: string;
        type: string;
        mode: string;
        fill: string;
        fillcolor: string;
        line: {
            color: string;
        };
        legendgroup?: undefined;
        hoverinfo?: undefined;
        text?: undefined;
    })[];
    exportToSpiderGraphData(categories: Categories[], type: ExportType, splitByCategory?: boolean): any[];
    exportToSpiderGraphData_Leaky(categories: Categories[], type: ExportType, splitByCategory?: boolean): any[];
    exportToHeatMapData(categories: Categories[], type: ExportType): {
        x: string[];
        y: Categories[];
        z: number[][];
        type: string;
        colorscale: string;
    }[];
    exportToLeakyIntegratorData(categories: (Categories | "Composite")[]): ({
        x: string[];
        y: number[];
        name: string;
        type: string;
        legendgroup?: undefined;
        hoverinfo?: undefined;
        text?: undefined;
        mode?: undefined;
        fillcolor?: undefined;
        line?: undefined;
        fill?: undefined;
    } | {
        x: string[];
        y: number[] | undefined;
        name: string;
        legendgroup: keyof import("@robotical/automatic-assessments").Scores | "Composite";
        hoverinfo: string;
        text: string[] | undefined;
        type: string;
        mode: string;
        fillcolor?: undefined;
        line?: undefined;
        fill?: undefined;
    } | {
        x: string[];
        y: number[] | undefined;
        name: string;
        type: string;
        mode: string;
        fillcolor: string;
        line: {
            color: string;
        };
        legendgroup?: undefined;
        hoverinfo?: undefined;
        text?: undefined;
        fill?: undefined;
    } | {
        x: string[];
        y: number[] | undefined;
        name: string;
        type: string;
        mode: string;
        fill: string;
        fillcolor: string;
        line: {
            color: string;
        };
        legendgroup?: undefined;
        hoverinfo?: undefined;
        text?: undefined;
    })[];
}
export {};