import type { EffectSizeStats } from '../effectSize/effectSizeStats.js';
import type { OptimalThresholdConfigBase } from '../kernelDensityEstimate.js';
import type { SplitMultiModalDistributionConfig } from '../modality/splitMultimodalDistributionWithKDE.js';
import type { SplitMultimodalDistributionWithQuantilesOptions } from '../modality/splitMultimodalDistributionWithQuantiles.js';
import type { ComparisonQualityWeightingOptions } from './compareSplitPermutations.js';
import type { KDEOptimizationParameters } from './compareWithKDEDenoising.js';
import type { QuantileOptimizationParameters } from './compareWithQuantileDenoising.js';
export interface AllTTests {
    twoSided: TTestResult;
    greater: TTestResult;
    less: TTestResult;
    degreesOfFreedom: number;
    tValue: number;
}
export interface ComparisonResult {
    outcome: ComparisonOutcome;
    outcomeFrequencies?: {
        [outcome in ComparisonOutcome]?: number;
    };
    ttest: AllTTests;
    ttestAdjusted?: {
        twoSided: TTestResultBase;
        greater: TTestResultBase;
        less: TTestResultBase;
    };
    meanDifference: number;
    stdevDifference: number;
    pooledVariance: number;
    pooledStDev: number;
    data1: SampleStatistics;
    data2: SampleStatistics;
    effectSizeStats: EffectSizeStats;
    originalResult?: ComparisonResult;
    denoiseSettings?: DenoiseSettings;
    comparedModalities1?: SampleStatistics[];
    comparedModalities2?: SampleStatistics[];
    discardedModalities1?: number[][];
    discardedModalities2?: number[][];
    mergedFromMultipleModalities?: boolean;
}
export type ConfidenceInterval = readonly [number | null, number | null];
export interface SampleStatistics {
    mean: number;
    variance: number;
    stdev: number;
    /** mean distance from consecutive ordered */
    meanDistanceRatio: number;
    normalityProbability: number;
    dataCount: number;
    data: number[];
    discardedCount: number;
    discardedData: number[];
    noiseCount?: number;
    modalityCount?: number;
    representativeMean?: number;
    representativeStdev?: number;
}
export interface TTestResultBase {
    pValue: number;
    rejected: boolean;
}
export interface TTestResult extends TTestResultBase {
    rejected: boolean;
    pValue: number;
    confidenceInterval: ConfidenceInterval;
}
export type DenoiseSettings = QuantileOptimizationParameters | KDEOptimizationParameters;
export type ComparisonOutcome = 'less' | 'greater' | 'equal' | 'similar' | 'invalid';
export type GetOutcomeOptions = {
    requireTwoSidedNullHypothesisRejection: boolean;
} & ({
    minimalAbsoluteChangeProbability: number;
} | {
    minimalCohensD: number;
});
export interface InternalGetOutcomeOptions {
    requireTwoSidedNullHypothesisRejection: boolean;
    minimalAbsoluteChangeProbability: number;
}
export interface KDEDenoisingOptions extends OptimalThresholdConfigBase, Pick<SplitMultiModalDistributionConfig, 'noiseValuesPerSample' | 'random' | 'iterations'> {
    kernelStretchFactorRange?: readonly [lower: number, upper: number];
    kernelStretchFactorSearchStepSize?: number;
}
export interface CompareWithDenoisingOptionsBase {
    data1: number[];
    data2: number[];
    sorted1: number[];
    sorted2: number[];
    stdev1: number;
    stdev2: number;
    confidenceLevel: number;
    getOutcomeOptions: InternalGetOutcomeOptions;
    minimalModalitySize: number;
    minimumUsedToTotalSamplesRatio: number;
    comparisonQualityWeightingOptions?: Partial<ComparisonQualityWeightingOptions>;
}
export type DenoisingAndModalitySplittingOptions = {
    type: 'none';
    options?: never;
} | {
    type: 'kde';
    options?: KDEDenoisingOptions;
} | {
    type: 'quantile';
    options?: SplitMultimodalDistributionWithQuantilesOptions;
};
//# sourceMappingURL=types.d.ts.map