import { ClassifierBase } from '../base';
import { Params } from '../base/estimator';
import { KernelConfig, KernelType, SMOSolution } from './smo';
export interface SVCProps {
    C?: number;
    kernel?: KernelType;
    /** 'scale' = 1/(n_features * Var(X)) like sklearn; 'auto' = 1/n_features */
    gamma?: number | 'scale' | 'auto';
    degree?: number;
    coef0?: number;
    tol?: number;
    /** hard limit on SMO pair updates; -1 (default) = run until convergence */
    maxIter?: number;
}
interface BinaryModel {
    /** training-set indices of this classifier's support vectors */
    indices: number[];
    /** alpha_i * y_i for each support vector */
    dualCoef: number[];
    b: number;
    /** class label voted for when the decision value is positive */
    positiveClass: number;
    negativeClass: number;
}
/**
 * C-Support Vector Classification solved in the dual with SMO (libsvm-style
 * maximal-violating-pair working-set selection). Multiclass problems are
 * handled one-vs-one like sklearn/libsvm.
 */
export declare class SVC extends ClassifierBase {
    protected C: number;
    protected kernel: KernelType;
    protected gamma: number | 'scale' | 'auto';
    protected degree: number;
    protected coef0: number;
    protected tol: number;
    protected maxIter: number;
    protected gammaValue: number;
    protected trainX: number[][];
    protected trainY: number[];
    protected classes: number[];
    protected models: BinaryModel[];
    constructor(props?: SVCProps);
    getParams(): Params;
    protected kernelConfig(): KernelConfig;
    protected resolveGamma(X: number[][]): number;
    /** solve one binary subproblem; y entries are +1/-1. Overridden by NuSVC. */
    protected solveBinary(X: number[][], y: number[]): SMOSolution;
    fit(trainX: number[][], trainY: number[]): void;
    protected checkFitted(): void;
    protected decisionValue(model: BinaryModel, x: number[]): number;
    predict(testX: number[][]): number[];
    /**
     * Binary-only decision function, sklearn convention: positive values
     * mean classes[1]. (The internal one-vs-one model is trained with
     * classes[0] as +1, hence the sign flip.)
     */
    decisionFunction(testX: number[][]): number[];
    /** sorted training-set indices of the support vectors (union over one-vs-one models) */
    getSupportVectors(): number[];
    /** number of support vectors per class, ordered like sklearn's n_support_ */
    getNSupport(): number[];
}
export {};