import { GraphFeatures } from './feature-extractor.js';
/**
 * Graph structural class labels.
 *
 * - erdos-renyi: Random graphs with uniform edge probability
 * - barabasi-albert: Scale-free graphs from preferential attachment
 * - watts-strogatz: Small-world graphs from ring lattice rewiring
 * - real-world: Empirical benchmark datasets
 */
export type GraphClass = "erdos-renyi" | "barabasi-albert" | "watts-strogatz" | "real-world";
/** All graph class labels for iteration. */
export declare const ALL_GRAPH_CLASSES: readonly GraphClass[];
/**
 * Result of classifying a single graph.
 */
export interface ClassificationResult {
    /** Predicted graph class */
    predictedClass: GraphClass;
    /** Confidence score: 1 - (nearest / sum of all distances). Range [0, 1]. */
    confidence: number;
    /** Euclidean distance to each class centroid */
    distances: Record<GraphClass, number>;
}
/**
 * A trained nearest-centroid classifier.
 *
 * Stores per-class centroids and feature scaling parameters
 * for z-score normalisation.
 */
export interface TrainedClassifier {
    /** Mean feature vector per class (in normalised space) */
    centroids: Record<GraphClass, number[]>;
    /** Ordered feature names matching vector indices */
    featureNames: string[];
    /** Z-score normalisation parameters computed from training data */
    featureScaling: {
        mean: number[];
        std: number[];
    };
}
/**
 * Train a nearest-centroid classifier.
 *
 * 1. Converts all feature objects to numeric vectors.
 * 2. Computes global mean and standard deviation per feature (z-score).
 * 3. Normalises all vectors.
 * 4. Computes the centroid (mean vector) per class.
 *
 * @param trainingData - Labelled training examples
 * @returns A trained classifier ready for classification
 * @throws Error if training data is empty or any class has zero examples
 */
export declare const trainClassifier: (trainingData: Array<{
    features: GraphFeatures;
    label: GraphClass;
}>) => TrainedClassifier;
/**
 * Classify a graph by finding the nearest centroid.
 *
 * Normalises the input features using the training scaling parameters,
 * then computes Euclidean distance to each class centroid.
 *
 * Confidence is computed as 1 - (nearestDistance / sumOfAllDistances).
 * When all distances are zero, confidence is 1.
 *
 * @param features - Structural features of the graph to classify
 * @param classifier - A previously trained classifier
 * @returns Classification result with predicted class, confidence, and distances
 */
export declare const classify: (features: GraphFeatures, classifier: TrainedClassifier) => ClassificationResult;
/**
 * Per-class precision, recall, F1, and support.
 */
export interface PerClassMetrics {
    precision: number;
    recall: number;
    f1: number;
    support: number;
}
/**
 * Multi-class classification metrics.
 */
export interface ClassificationMetrics {
    /** Overall accuracy (correct / total) */
    accuracy: number;
    /** Per-class precision, recall, F1, and support */
    perClass: Record<GraphClass, PerClassMetrics>;
    /** Macro-averaged F1 (unweighted mean of per-class F1 scores) */
    macroF1: number;
}
/**
 * Evaluate classifier predictions against ground truth labels.
 *
 * Computes accuracy, per-class precision/recall/F1, and macro F1.
 *
 * @param predictions - Array of predicted and actual class labels
 * @returns Multi-class classification metrics
 */
export declare const evaluateClassifier: (predictions: Array<{
    predicted: GraphClass;
    actual: GraphClass;
}>) => ClassificationMetrics;
//# sourceMappingURL=graph-classifier.d.ts.map