import { BaseEstimator, TransformerBase } from '../base';
import { Params } from '../base/estimator';
export { SplineTransformer, TargetEncoder } from './preprocessingAdvanced';
export type { SplineTransformerProps, SplineKnots, SplineExtrapolation, TargetEncoderProps, Category, TargetLabel } from './preprocessingAdvanced';
export interface StandardScalerProps {
    withMean?: boolean;
    withStd?: boolean;
}
export interface MinMaxScalerProps {
    featureRange?: [number, number];
}
export interface NormalizerProps {
    norm?: 'l1' | 'l2' | 'max';
}
export interface BinarizerProps {
    threshold?: number;
}
export interface SimpleImputerProps {
    strategy?: 'mean' | 'median' | 'mostFrequent' | 'constant';
    fillValue?: number;
    missingValues?: number | null;
}
export interface VarianceThresholdProps {
    threshold?: number;
}
export type FeatureScoreFunc = (X: number[][], y: number[]) => number[];
export interface SelectKBestProps {
    k?: number;
    /**
     * Either a scoring function or the string name of a built-in
     * (e.g. 'fRegression'). Only string names are serializable; passing a raw
     * function makes `toJSON()` throw (documented codec behavior).
     */
    scoreFunc?: FeatureScoreFunc | string;
}
export type CategoricalValue = string | number | boolean | null;
export interface OneHotEncoderProps {
    drop?: 'none' | 'first' | 'ifBinary';
}
export declare class StandardScaler extends TransformerBase {
    private withMean;
    private withStd;
    private means;
    private scales;
    private fitted;
    constructor(props?: StandardScalerProps);
    getParams(): Params;
    fit(X: number[][]): void;
    private assertFittedAndShape;
    transform(X: number[][]): number[][];
    fitTransform(X: number[][]): number[][];
    inverseTransform(X: number[][]): number[][];
}
export declare class MinMaxScaler extends TransformerBase {
    private featureRange;
    private dataMin;
    private scales;
    private offsets;
    private fitted;
    constructor(props?: MinMaxScalerProps);
    getParams(): Params;
    fit(X: number[][]): void;
    private assertFittedAndShape;
    transform(X: number[][]): number[][];
    fitTransform(X: number[][]): number[][];
    inverseTransform(X: number[][]): number[][];
}
export declare class MaxAbsScaler extends TransformerBase {
    private maxAbs;
    private fitted;
    constructor(_props?: Record<string, never>);
    getParams(): Params;
    fit(X: number[][]): void;
    transform(X: number[][]): number[][];
    fitTransform(X: number[][]): number[][];
    inverseTransform(X: number[][]): number[][];
}
export declare class Normalizer extends TransformerBase {
    private norm;
    constructor(props?: NormalizerProps);
    getParams(): Params;
    fit(_X: number[][]): void;
    transform(X: number[][]): number[][];
    fitTransform(X: number[][]): number[][];
}
/**
 * Operates on 1-D label arrays rather than X matrices, so it extends
 * BaseEstimator directly (see the estimator contract, "estimators that fit
 * none of these signatures").
 */
export declare class LabelEncoder extends BaseEstimator {
    private classes;
    private fitted;
    constructor(_props?: Record<string, never>);
    getParams(): Params;
    fit(y: number[]): void;
    transform(y: number[]): number[];
    fitTransform(y: number[]): number[];
    inverseTransform(y: number[]): number[];
}
export declare class Binarizer extends TransformerBase {
    private threshold;
    constructor(props?: BinarizerProps);
    getParams(): Params;
    fit(_X: number[][]): void;
    transform(X: number[][]): number[][];
    fitTransform(X: number[][]): number[][];
}
/**
 * Operates on categorical matrices (`CategoricalValue[][]`) and its
 * `inverseTransform` returns categorical values, so it cannot satisfy
 * TransformerBase's numeric signatures; it extends BaseEstimator directly
 * per the estimator contract.
 */
export declare class OrdinalEncoder extends BaseEstimator {
    private categories;
    private fitted;
    constructor(_props?: Record<string, never>);
    getParams(): Params;
    fit(X: CategoricalValue[][]): void;
    transform(X: CategoricalValue[][]): number[][];
    fitTransform(X: CategoricalValue[][]): number[][];
    inverseTransform(X: number[][]): CategoricalValue[][];
}
/**
 * Operates on categorical matrices; extends BaseEstimator directly for the
 * same reason as OrdinalEncoder.
 */
export declare class OneHotEncoder extends BaseEstimator {
    private drop;
    private categories;
    private retainedCategories;
    private fitted;
    constructor(props?: OneHotEncoderProps);
    getParams(): Params;
    private categoriesToEncode;
    fit(X: CategoricalValue[][]): void;
    transform(X: CategoricalValue[][]): number[][];
    fitTransform(X: CategoricalValue[][]): number[][];
    inverseTransform(X: number[][]): CategoricalValue[][];
}
export declare class SimpleImputer extends TransformerBase {
    private strategy;
    private fillValue;
    private missingValues;
    private statistics;
    private fitted;
    constructor(props?: SimpleImputerProps);
    getParams(): Params;
    fit(X: number[][]): void;
    transform(X: number[][]): number[][];
    fitTransform(X: number[][]): number[][];
}
export declare class VarianceThreshold extends TransformerBase {
    private threshold;
    private selectedIndices;
    private fitted;
    constructor(props?: VarianceThresholdProps);
    getParams(): Params;
    fit(X: number[][]): void;
    transform(X: number[][]): number[][];
    fitTransform(X: number[][]): number[][];
}
export declare function fRegression(X: number[][], y: number[]): number[];
export declare class SelectKBest extends TransformerBase {
    private k;
    private scoreFunc;
    private selectedIndices;
    private fitted;
    constructor(props?: SelectKBestProps);
    getParams(): Params;
    private resolveScoreFunc;
    fit(X: number[][], y: number[]): void;
    transform(X: number[][]): number[][];
    fitTransform(X: number[][], y: number[]): number[][];
}
export * from './preprocessingExtra';