import * as Distance from './distances';
export declare function accuracyScore(actual: number[], expected: number[], normalize?: boolean): number;
export interface ClassificationMetricOptions {
    average?: 'binary' | 'macro';
    positiveLabel?: number;
}
export interface PrecisionRecallFscoreSupportResult {
    precision: number;
    recall: number;
    fScore: number;
    support: number[];
}
export declare function precisionScore(actual: number[], expected: number[], options?: ClassificationMetricOptions): number;
export declare function recallScore(actual: number[], expected: number[], options?: ClassificationMetricOptions): number;
export declare function f1Score(actual: number[], expected: number[], options?: ClassificationMetricOptions): number;
export declare function precisionRecallFscoreSupport(actual: number[], expected: number[], options?: ClassificationMetricOptions): PrecisionRecallFscoreSupportResult;
export declare function meanSquaredError(actual: number[], expected: number[]): number;
export declare function r2Score(actual: number[], expected: number[]): number;
export declare function confusionMatrix(actual: number[], expected: number[], labels?: number[]): number[][];
export declare function rocCurve(expected: number[], scores: number[], positiveLabel?: number): {
    fpr: number[];
    tpr: number[];
    thresholds: number[];
};
export interface RocAucOptions {
    /** Positive label for the binary case (default 1), like the old third positional argument. */
    positiveLabel?: number;
    /**
     * Multiclass strategy, required when `scores` is a probability matrix
     * (sklearn's default multi_class='raise' behaviour).
     */
    multiClass?: 'ovr' | 'ovo';
    /** Averaging strategy for the multiclass case (sklearn default 'macro'). */
    average?: 'macro' | 'weighted';
}
/**
 * Area under the ROC curve. Mirrors sklearn.metrics.roc_auc_score.
 * Argument order: (expected, scores) — ground truth first, then scores,
 * matching rocCurve/precisionRecallCurve in this module.
 *
 * Binary: `scores` is a 1-D array of decision scores/probabilities of the
 * positive class (third argument may be the positive label, default 1).
 * Multiclass: `scores` is an n-samples x n-classes probability matrix whose
 * columns follow the sorted unique labels of `expected`; the third argument
 * must then supply `multiClass: 'ovr' | 'ovo'`.
 */
export declare function rocAucScore(expected: number[], scores: number[], positiveLabel?: number): number;
export declare function rocAucScore(expected: number[], scores: number[][], options?: RocAucOptions): number;
export declare function precisionRecallCurve(expected: number[], scores: number[], positiveLabel?: number): {
    precision: number[];
    recall: number[];
    thresholds: number[];
};
export declare function adjustedRandScore(labelsTrue: number[], labelsPred: number[]): number;
export interface LogLossOptions {
    /** Probability clipping epsilon; 'auto' (default) uses Number.EPSILON like modern sklearn. */
    eps?: number | 'auto';
    /** If true (default) return the mean per-sample loss, otherwise the sum. */
    normalize?: boolean;
    /** Explicit class labels (required when expected contains a single class). */
    labels?: number[];
}
/**
 * Log loss / cross-entropy. Mirrors sklearn.metrics.log_loss.
 * Argument order: (expected, predictedProbabilities) — ground truth first,
 * matching this module's score-based metrics (rocCurve/rocAucScore).
 *
 * `predictedProbabilities` is either 1-D (binary: probability of the greater
 * label) or an n-samples x n-classes matrix whose columns follow the sorted
 * class labels. Rows must sum to 1 (sklearn >= 1.5 raises otherwise).
 */
export declare function logLoss(expected: number[], predictedProbabilities: number[] | number[][], options?: LogLossOptions): number;
export interface BalancedAccuracyOptions {
    /** If true, chance-adjust the score so random performance scores 0 (sklearn `adjusted`). */
    adjusted?: boolean;
}
/**
 * Balanced accuracy: macro-average of per-class recall. Mirrors
 * sklearn.metrics.balanced_accuracy_score (classes without true samples are
 * dropped from the average, as sklearn does).
 * Argument order: (actual, expected) — predictions first, ground truth second,
 * matching accuracyScore.
 */
export declare function balancedAccuracyScore(actual: number[], expected: number[], options?: BalancedAccuracyOptions): number;
/**
 * Matthews correlation coefficient using the multiclass-safe covariance
 * formulation. Mirrors sklearn.metrics.matthews_corrcoef, including the
 * documented convention of returning 0 when the denominator is 0.
 * Argument order: (actual, expected) — predictions first, ground truth second.
 */
export declare function matthewsCorrcoef(actual: number[], expected: number[]): number;
export interface CohenKappaOptions {
    /** Weighting scheme for disagreements (sklearn `weights`); undefined = unweighted. */
    weights?: 'linear' | 'quadratic';
    /** Explicit label list (sklearn `labels`). */
    labels?: number[];
}
/**
 * Cohen's kappa between two annotators. Mirrors sklearn.metrics.cohen_kappa_score
 * (symmetric in its two label arrays).
 * Argument order: (y1, y2) — two labelings, like sklearn.
 */
export declare function cohenKappaScore(y1: number[], y2: number[], options?: CohenKappaOptions): number;
/**
 * Average hinge loss for binary problems. Mirrors sklearn.metrics.hinge_loss
 * for the binary case: the greater of the two labels is treated as the
 * positive class (+1), the other as -1, and loss_i = max(0, 1 - y_i * d_i).
 * Argument order: (expected, decisions) — ground truth first, then decision
 * function values, matching the module's score-based metrics.
 */
export declare function hingeLoss(expected: number[], decisions: number[]): number;
export interface BrierScoreLossOptions {
    /** Label treated as the positive class (sklearn `pos_label`). */
    positiveLabel?: number;
}
/**
 * Brier score loss for binary problems: mean((p_i - 1{y_i == pos})^2).
 * Mirrors sklearn.metrics.brier_score_loss. When positiveLabel is omitted it
 * defaults to 1 provided the labels are within {-1, 0, 1} (sklearn raises
 * otherwise, and so do we).
 * Argument order: (expected, probabilities) — ground truth first, then the
 * predicted probability of the positive class.
 */
export declare function brierScoreLoss(expected: number[], probabilities: number[], options?: BrierScoreLossOptions): number;
export interface ClassificationReportRow {
    precision: number;
    recall: number;
    f1Score: number;
    support: number;
}
export interface ClassificationReportResult {
    perClass: {
        [label: string]: ClassificationReportRow;
    };
    accuracy: number;
    macroAvg: ClassificationReportRow;
    weightedAvg: ClassificationReportRow;
}
/**
 * Structured classification report matching the numbers produced by
 * sklearn.metrics.classification_report(..., output_dict=True): per-class
 * precision/recall/F1/support plus accuracy, macro and support-weighted
 * averages (avg rows carry the total support).
 * Argument order: (actual, expected) — predictions first, ground truth second.
 */
export declare function classificationReport(actual: number[], expected: number[]): ClassificationReportResult;
/**
 * Mean absolute error. Mirrors sklearn.metrics.mean_absolute_error.
 * Argument order: (actual, expected) — predictions first, ground truth second,
 * matching meanSquaredError.
 */
export declare function meanAbsoluteError(actual: number[], expected: number[]): number;
/**
 * Mean absolute percentage error with sklearn's epsilon clamping:
 * mean(|y_true - y_pred| / max(|y_true|, eps)) with eps = machine epsilon,
 * mirroring sklearn.metrics.mean_absolute_percentage_error.
 * Argument order: (actual, expected) — predictions first, ground truth second.
 */
export declare function meanAbsolutePercentageError(actual: number[], expected: number[]): number;
/**
 * Median absolute error. Mirrors sklearn.metrics.median_absolute_error
 * (even-length medians are the mean of the two central values).
 * Argument order: (actual, expected) — predictions first, ground truth second.
 */
export declare function medianAbsoluteError(actual: number[], expected: number[]): number;
/**
 * Mean squared logarithmic error: mean((log1p(y_true) - log1p(y_pred))^2).
 * Mirrors sklearn.metrics.mean_squared_log_error, including throwing when
 * either targets or predictions contain negative values.
 * Argument order: (actual, expected) — predictions first, ground truth second.
 */
export declare function meanSquaredLogError(actual: number[], expected: number[]): number;
/**
 * Explained variance score: 1 - Var(y_true - y_pred) / Var(y_true).
 * Mirrors sklearn.metrics.explained_variance_score with force_finite=True:
 * when Var(y_true) is 0 the score is 1 for a perfect fit and 0 otherwise.
 * Argument order: (actual, expected) — predictions first, ground truth second.
 */
export declare function explainedVarianceScore(actual: number[], expected: number[]): number;
/**
 * Maximum residual error. Mirrors sklearn.metrics.max_error.
 * Argument order: (actual, expected) — predictions first, ground truth second.
 */
export declare function maxError(actual: number[], expected: number[]): number;
/**
 * Root mean squared error: sqrt(meanSquaredError). Mirrors
 * sklearn.metrics.root_mean_squared_error.
 * Argument order: (actual, expected) — predictions first, ground truth second.
 */
export declare function rootMeanSquaredError(actual: number[], expected: number[]): number;
export interface SilhouetteOptions {
    /** 'euclidean' (default) treats X as points; 'precomputed' treats X as a distance matrix. */
    metric?: 'euclidean' | 'precomputed';
}
/**
 * Per-sample silhouette coefficients. Mirrors sklearn.metrics.silhouette_samples
 * (singleton clusters score 0; 0/0 degenerate samples are mapped to 0).
 * Argument order: (X, labels).
 */
export declare function silhouetteSamples(X: number[][], labels: number[], options?: SilhouetteOptions): number[];
/**
 * Mean silhouette coefficient over all samples. Mirrors
 * sklearn.metrics.silhouette_score (euclidean or precomputed distances;
 * requires 2 <= nLabels <= nSamples - 1 and throws otherwise).
 * Argument order: (X, labels).
 */
export declare function silhouetteScore(X: number[][], labels: number[], options?: SilhouetteOptions): number;
/**
 * Davies-Bouldin index (lower is better, 0 is the minimum). Mirrors
 * sklearn.metrics.davies_bouldin_score with euclidean distances.
 * Argument order: (X, labels).
 */
export declare function daviesBouldinScore(X: number[][], labels: number[]): number;
/**
 * Calinski-Harabasz index (variance-ratio criterion, higher is better).
 * Mirrors sklearn.metrics.calinski_harabasz_score, including returning 1.0
 * when the within-cluster dispersion is 0.
 * Argument order: (X, labels).
 */
export declare function calinskiHarabaszScore(X: number[][], labels: number[]): number;
/**
 * Mutual information (natural log) between two clusterings. Mirrors
 * sklearn.metrics.mutual_info_score (clipped at 0 to absorb float error).
 * Argument order: (labelsTrue, labelsPred), matching adjustedRandScore.
 */
export declare function mutualInfoScore(labelsTrue: number[], labelsPred: number[]): number;
/**
 * Homogeneity: each cluster contains only members of a single class.
 * Mirrors sklearn.metrics.homogeneity_score.
 * Argument order: (labelsTrue, labelsPred).
 */
export declare function homogeneityScore(labelsTrue: number[], labelsPred: number[]): number;
/**
 * Completeness: all members of a class are assigned to the same cluster.
 * Mirrors sklearn.metrics.completeness_score.
 * Argument order: (labelsTrue, labelsPred).
 */
export declare function completenessScore(labelsTrue: number[], labelsPred: number[]): number;
/**
 * V-measure: harmonic mean of homogeneity and completeness (beta = 1).
 * Mirrors sklearn.metrics.v_measure_score.
 * Argument order: (labelsTrue, labelsPred).
 */
export declare function vMeasureScore(labelsTrue: number[], labelsPred: number[]): number;
export type MutualInfoAverageMethod = 'min' | 'geometric' | 'arithmetic' | 'max';
export interface NormalizedMutualInfoOptions {
    /** How to average the two entropies for normalization (sklearn default 'arithmetic'). */
    averageMethod?: MutualInfoAverageMethod;
}
/**
 * Normalized mutual information: MI / average(H(true), H(pred)).
 * Mirrors sklearn.metrics.normalized_mutual_info_score, including the special
 * cases: two single-cluster labelings score 1.0 and MI of exactly 0 scores 0.
 * Argument order: (labelsTrue, labelsPred).
 */
export declare function normalizedMutualInfoScore(labelsTrue: number[], labelsPred: number[], options?: NormalizedMutualInfoOptions): number;
/**
 * Adjusted mutual information: (MI - E[MI]) / (average(H_true, H_pred) - E[MI]).
 * Mirrors sklearn.metrics.adjusted_mutual_info_score with the arithmetic
 * average default and the same epsilon-guarded denominator.
 * Argument order: (labelsTrue, labelsPred).
 */
export declare function adjustedMutualInfoScore(labelsTrue: number[], labelsPred: number[], options?: NormalizedMutualInfoOptions): number;
/**
 * Fowlkes-Mallows index: geometric mean of pairwise precision and recall.
 * Mirrors sklearn.metrics.fowlkes_mallows_score (0 when there are no pairs
 * clustered together in both assignments).
 * Argument order: (labelsTrue, labelsPred).
 */
export declare function fowlkesMallowsScore(labelsTrue: number[], labelsPred: number[]): number;
/**
 * (Unadjusted) Rand index: fraction of sample pairs on which the two
 * clusterings agree. Mirrors sklearn.metrics.rand_score.
 * Argument order: (labelsTrue, labelsPred).
 */
export declare function randScore(labelsTrue: number[], labelsPred: number[]): number;
export { Distance };