nodepyx 1.0.0

package/src/types/stubs/sklearn.d.ts

@@ -0,0 +1,728 @@
+// =============================================================
+// nodepyx — Pre-built TypeScript stub for scikit-learn
+// Version: 1.x
+// Source: https://scikit-learn.org
+// =============================================================
+
+import type { PyProxy } from 'nodepyx';
+
+declare module 'nodepyx/sklearn' {
+
+  export type NDArray = Float64Array | Float32Array | Int32Array | Uint8Array;
+
+  // ── Base estimator interface ───────────────────────────────────────────────
+
+  export interface Estimator {
+    fit(X: NDArray | PyProxy, y?: NDArray | PyProxy | null, ...kwargs: unknown[]): Promise<this>;
+    get_params(deep?: boolean): Promise<Record<string, unknown>>;
+    set_params(params: Record<string, unknown>): Promise<this>;
+    [key: string]: unknown;
+  }
+
+  // ── sklearn.linear_model ──────────────────────────────────────────────────
+
+  export namespace linear_model {
+    export class LinearRegression {
+      constructor(fit_intercept?: boolean, normalize?: boolean, copy_X?: boolean, n_jobs?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy, sample_weight?: NDArray | null): Promise<LinearRegression>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy, sample_weight?: NDArray | null): Promise<number>;
+      get_params(deep?: boolean): Promise<Record<string, unknown>>;
+      set_params(params: Record<string, unknown>): Promise<LinearRegression>;
+      readonly coef_: Promise<NDArray>;
+      readonly intercept_: Promise<NDArray | number>;
+      readonly rank_: Promise<number>;
+      readonly singular_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class LogisticRegression {
+      constructor(penalty?: 'l1' | 'l2' | 'elasticnet' | null, C?: number, max_iter?: number, solver?: string, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy, sample_weight?: NDArray | null): Promise<LogisticRegression>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_log_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      decision_function(X: NDArray | PyProxy): Promise<NDArray>;
+      get_params(deep?: boolean): Promise<Record<string, unknown>>;
+      readonly coef_: Promise<NDArray>;
+      readonly intercept_: Promise<NDArray>;
+      readonly classes_: Promise<NDArray>;
+      readonly n_iter_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class Ridge {
+      constructor(alpha?: number, fit_intercept?: boolean, max_iter?: number | null, tol?: number, solver?: string);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy, sample_weight?: NDArray | null): Promise<Ridge>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      readonly coef_: Promise<NDArray>;
+      readonly intercept_: Promise<NDArray | number>;
+      [key: string]: unknown;
+    }
+
+    export class Lasso {
+      constructor(alpha?: number, fit_intercept?: boolean, max_iter?: number, tol?: number);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy, sample_weight?: NDArray | null): Promise<Lasso>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      readonly coef_: Promise<NDArray>;
+      readonly intercept_: Promise<NDArray | number>;
+      readonly n_iter_: Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class ElasticNet {
+      constructor(alpha?: number, l1_ratio?: number, fit_intercept?: boolean, max_iter?: number);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<ElasticNet>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class SGDClassifier {
+      constructor(loss?: string, penalty?: string, alpha?: number, max_iter?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<SGDClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class SGDRegressor {
+      constructor(loss?: string, penalty?: string, alpha?: number, max_iter?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<SGDRegressor>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+  }
+
+  // ── sklearn.ensemble ──────────────────────────────────────────────────────
+
+  export namespace ensemble {
+    export class RandomForestClassifier {
+      constructor(
+        n_estimators?: number,
+        max_depth?: number | null,
+        min_samples_split?: number,
+        min_samples_leaf?: number,
+        max_features?: string | number,
+        random_state?: number | null,
+        n_jobs?: number | null,
+        verbose?: number,
+        class_weight?: string | Record<number, number> | null,
+      );
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy, sample_weight?: NDArray | null): Promise<RandomForestClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      get_params(deep?: boolean): Promise<Record<string, unknown>>;
+      set_params(params: Record<string, unknown>): Promise<RandomForestClassifier>;
+      readonly feature_importances_: Promise<NDArray>;
+      readonly estimators_: Promise<PyProxy[]>;
+      readonly classes_: Promise<NDArray>;
+      readonly n_classes_: Promise<number>;
+      readonly n_features_: Promise<number>;
+      readonly n_features_in_: Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class RandomForestRegressor {
+      constructor(n_estimators?: number, max_depth?: number | null, random_state?: number | null, n_jobs?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<RandomForestRegressor>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      readonly feature_importances_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class GradientBoostingClassifier {
+      constructor(n_estimators?: number, learning_rate?: number, max_depth?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<GradientBoostingClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      readonly feature_importances_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class GradientBoostingRegressor {
+      constructor(n_estimators?: number, learning_rate?: number, max_depth?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<GradientBoostingRegressor>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class AdaBoostClassifier {
+      constructor(n_estimators?: number, learning_rate?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<AdaBoostClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class BaggingClassifier {
+      constructor(base_estimator?: PyProxy, n_estimators?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<BaggingClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class ExtraTreesClassifier {
+      constructor(n_estimators?: number, max_depth?: number | null, random_state?: number | null, n_jobs?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<ExtraTreesClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      readonly feature_importances_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class VotingClassifier {
+      constructor(estimators: [string, PyProxy][], voting?: 'hard' | 'soft');
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<VotingClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class StackingClassifier {
+      constructor(estimators: [string, PyProxy][], final_estimator?: PyProxy | null, cv?: number | string);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<StackingClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+  }
+
+  // ── sklearn.tree ──────────────────────────────────────────────────────────
+
+  export namespace tree {
+    export class DecisionTreeClassifier {
+      constructor(criterion?: 'gini' | 'entropy', max_depth?: number | null, min_samples_split?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<DecisionTreeClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      readonly feature_importances_: Promise<NDArray>;
+      readonly tree_: Promise<PyProxy>;
+      [key: string]: unknown;
+    }
+
+    export class DecisionTreeRegressor {
+      constructor(criterion?: 'mse' | 'friedman_mse' | 'mae', max_depth?: number | null, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<DecisionTreeRegressor>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export function export_graphviz(
+      decision_tree: PyProxy,
+      out_file?: string | null,
+      max_depth?: number | null,
+      feature_names?: string[],
+      class_names?: string[],
+    ): Promise<string | null>;
+  }
+
+  // ── sklearn.svm ───────────────────────────────────────────────────────────
+
+  export namespace svm {
+    export class SVC {
+      constructor(C?: number, kernel?: 'linear' | 'poly' | 'rbf' | 'sigmoid', gamma?: string | number, probability?: boolean, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<SVC>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      decision_function(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly support_vectors_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class SVR {
+      constructor(kernel?: string, C?: number, gamma?: string | number, epsilon?: number);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<SVR>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class LinearSVC {
+      constructor(C?: number, max_iter?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<LinearSVC>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class NuSVC {
+      constructor(nu?: number, kernel?: string, probability?: boolean);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<NuSVC>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+  }
+
+  // ── sklearn.preprocessing ────────────────────────────────────────────────
+
+  export namespace preprocessing {
+    export class StandardScaler {
+      constructor(copy?: boolean, with_mean?: boolean, with_std?: boolean);
+      fit(X: NDArray | PyProxy, y?: null): Promise<StandardScaler>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      inverse_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      get_params(deep?: boolean): Promise<Record<string, unknown>>;
+      readonly mean_: Promise<NDArray>;
+      readonly scale_: Promise<NDArray>;
+      readonly var_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class MinMaxScaler {
+      constructor(feature_range?: [number, number], copy?: boolean);
+      fit(X: NDArray | PyProxy): Promise<MinMaxScaler>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      inverse_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly data_min_: Promise<NDArray>;
+      readonly data_max_: Promise<NDArray>;
+      readonly scale_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class RobustScaler {
+      constructor(with_centering?: boolean, with_scaling?: boolean, quantile_range?: [number, number]);
+      fit(X: NDArray | PyProxy): Promise<RobustScaler>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      inverse_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class LabelEncoder {
+      constructor();
+      fit(y: NDArray | PyProxy | unknown[]): Promise<LabelEncoder>;
+      transform(y: NDArray | PyProxy | unknown[]): Promise<NDArray>;
+      fit_transform(y: NDArray | PyProxy | unknown[]): Promise<NDArray>;
+      inverse_transform(y: NDArray | PyProxy): Promise<NDArray>;
+      readonly classes_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class OneHotEncoder {
+      constructor(categories?: 'auto' | unknown[][], drop?: null | string | unknown[], sparse?: boolean, dtype?: string);
+      fit(X: NDArray | PyProxy): Promise<OneHotEncoder>;
+      transform(X: NDArray | PyProxy): Promise<NDArray | PyProxy>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray | PyProxy>;
+      inverse_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      get_feature_names_out(input_features?: string[]): Promise<string[]>;
+      readonly categories_: Promise<NDArray[]>;
+      [key: string]: unknown;
+    }
+
+    export class PolynomialFeatures {
+      constructor(degree?: number, interaction_only?: boolean, include_bias?: boolean);
+      fit(X: NDArray | PyProxy): Promise<PolynomialFeatures>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      get_feature_names_out(input_features?: string[]): Promise<string[]>;
+      readonly n_output_features_: Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class Normalizer {
+      constructor(norm?: 'l1' | 'l2' | 'max');
+      fit(X: NDArray | PyProxy): Promise<Normalizer>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export function normalize(X: NDArray | PyProxy, norm?: 'l1' | 'l2' | 'max', axis?: number, copy?: boolean): Promise<NDArray>;
+    export function scale(X: NDArray | PyProxy, axis?: number, with_mean?: boolean, with_std?: boolean, copy?: boolean): Promise<NDArray>;
+    export function binarize(X: NDArray | PyProxy, threshold?: number): Promise<NDArray>;
+    export function label_binarize(y: unknown[], classes: unknown[], neg_label?: number, pos_label?: number): Promise<NDArray>;
+  }
+
+  // ── sklearn.model_selection ──────────────────────────────────────────────
+
+  export namespace model_selection {
+    export function train_test_split(
+      ...arrays: (NDArray | PyProxy)[],
+    ): Promise<[NDArray, NDArray, NDArray, NDArray]>;
+
+    export function cross_val_score(
+      estimator: PyProxy,
+      X: NDArray | PyProxy,
+      y?: NDArray | PyProxy | null,
+      scoring?: string | null,
+      cv?: number | PyProxy,
+      n_jobs?: number | null,
+    ): Promise<NDArray>;
+
+    export function cross_validate(
+      estimator: PyProxy,
+      X: NDArray | PyProxy,
+      y?: NDArray | PyProxy | null,
+      scoring?: string | string[] | null,
+      cv?: number | PyProxy,
+    ): Promise<Record<string, NDArray>>;
+
+    export class GridSearchCV {
+      constructor(
+        estimator: PyProxy,
+        param_grid: Record<string, unknown[]>,
+        scoring?: string | null,
+        n_jobs?: number | null,
+        cv?: number,
+        refit?: boolean,
+        verbose?: number,
+      );
+      fit(X: NDArray | PyProxy, y?: NDArray | PyProxy | null): Promise<GridSearchCV>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      readonly best_estimator_: Promise<PyProxy>;
+      readonly best_params_: Promise<Record<string, unknown>>;
+      readonly best_score_: Promise<number>;
+      readonly cv_results_: Promise<Record<string, NDArray | unknown[]>>;
+      [key: string]: unknown;
+    }
+
+    export class RandomizedSearchCV {
+      constructor(
+        estimator: PyProxy,
+        param_distributions: Record<string, unknown[]>,
+        n_iter?: number,
+        scoring?: string | null,
+        n_jobs?: number | null,
+        cv?: number,
+        random_state?: number | null,
+      );
+      fit(X: NDArray | PyProxy, y?: NDArray | PyProxy | null): Promise<RandomizedSearchCV>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      readonly best_estimator_: Promise<PyProxy>;
+      readonly best_params_: Promise<Record<string, unknown>>;
+      readonly best_score_: Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class KFold {
+      constructor(n_splits?: number, shuffle?: boolean, random_state?: number | null);
+      split(X: NDArray | PyProxy, y?: NDArray | PyProxy | null): PyProxy;
+      get_n_splits(X?: NDArray | PyProxy | null, y?: NDArray | PyProxy | null): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class StratifiedKFold {
+      constructor(n_splits?: number, shuffle?: boolean, random_state?: number | null);
+      split(X: NDArray | PyProxy, y: NDArray | PyProxy): PyProxy;
+      get_n_splits(): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class LeaveOneOut {
+      constructor();
+      split(X: NDArray | PyProxy): PyProxy;
+      get_n_splits(X: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+  }
+
+  // ── sklearn.metrics ───────────────────────────────────────────────────────
+
+  export namespace metrics {
+    export function accuracy_score(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy, normalize?: boolean, sample_weight?: NDArray | null): Promise<number>;
+    export function precision_score(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy, average?: 'binary' | 'micro' | 'macro' | 'weighted' | null): Promise<number | NDArray>;
+    export function recall_score(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy, average?: 'binary' | 'micro' | 'macro' | 'weighted' | null): Promise<number | NDArray>;
+    export function f1_score(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy, average?: 'binary' | 'micro' | 'macro' | 'weighted' | null): Promise<number | NDArray>;
+    export function classification_report(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy, target_names?: string[], output_dict?: false): Promise<string>;
+    export function confusion_matrix(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy, labels?: unknown[], normalize?: 'true' | 'pred' | 'all' | null): Promise<NDArray>;
+    export function roc_auc_score(y_true: NDArray | PyProxy, y_score: NDArray | PyProxy, average?: string, multi_class?: string): Promise<number>;
+    export function roc_curve(y_true: NDArray | PyProxy, y_score: NDArray | PyProxy, pos_label?: number): Promise<[NDArray, NDArray, NDArray]>;
+    export function precision_recall_curve(y_true: NDArray | PyProxy, probas_pred: NDArray | PyProxy): Promise<[NDArray, NDArray, NDArray]>;
+    export function mean_squared_error(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy, sample_weight?: NDArray | null, squared?: boolean): Promise<number>;
+    export function mean_absolute_error(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy): Promise<number>;
+    export function r2_score(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy): Promise<number>;
+    export function log_loss(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy): Promise<number>;
+    export function balanced_accuracy_score(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy): Promise<number>;
+    export function explained_variance_score(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy): Promise<number>;
+    export function mean_absolute_percentage_error(y_true: NDArray | PyProxy, y_pred: NDArray | PyProxy): Promise<number>;
+    export function cohen_kappa_score(y1: NDArray | PyProxy, y2: NDArray | PyProxy): Promise<number>;
+    export function silhouette_score(X: NDArray | PyProxy, labels: NDArray | PyProxy, metric?: string): Promise<number>;
+    export function calinski_harabasz_score(X: NDArray | PyProxy, labels: NDArray | PyProxy): Promise<number>;
+    export function davies_bouldin_score(X: NDArray | PyProxy, labels: NDArray | PyProxy): Promise<number>;
+    export function make_scorer(score_func: PyProxy, greater_is_better?: boolean, ...kwargs: unknown[]): Promise<PyProxy>;
+  }
+
+  // ── sklearn.decomposition ────────────────────────────────────────────────
+
+  export namespace decomposition {
+    export class PCA {
+      constructor(n_components?: number | string | null, whiten?: boolean, random_state?: number | null);
+      fit(X: NDArray | PyProxy): Promise<PCA>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      inverse_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      get_params(deep?: boolean): Promise<Record<string, unknown>>;
+      readonly components_: Promise<NDArray>;
+      readonly explained_variance_: Promise<NDArray>;
+      readonly explained_variance_ratio_: Promise<NDArray>;
+      readonly singular_values_: Promise<NDArray>;
+      readonly n_components_: Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class TruncatedSVD {
+      constructor(n_components?: number, n_iter?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy): Promise<TruncatedSVD>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      inverse_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly components_: Promise<NDArray>;
+      readonly explained_variance_ratio_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class NMF {
+      constructor(n_components?: number | null, init?: string, random_state?: number | null, max_iter?: number);
+      fit(X: NDArray | PyProxy): Promise<NMF>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly components_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class KernelPCA {
+      constructor(n_components?: number | null, kernel?: string, gamma?: number | null, degree?: number, coef0?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy): Promise<KernelPCA>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class FastICA {
+      constructor(n_components?: number | null, algorithm?: string, max_iter?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy): Promise<FastICA>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly components_: Promise<NDArray>;
+      readonly mixing_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+  }
+
+  // ── sklearn.cluster ───────────────────────────────────────────────────────
+
+  export namespace cluster {
+    export class KMeans {
+      constructor(n_clusters?: number, init?: string, max_iter?: number, n_init?: number, random_state?: number | null, verbose?: number);
+      fit(X: NDArray | PyProxy): Promise<KMeans>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_predict(X: NDArray | PyProxy): Promise<NDArray>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy): Promise<number>;
+      get_params(deep?: boolean): Promise<Record<string, unknown>>;
+      readonly labels_: Promise<NDArray>;
+      readonly cluster_centers_: Promise<NDArray>;
+      readonly inertia_: Promise<number>;
+      readonly n_iter_: Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class DBSCAN {
+      constructor(eps?: number, min_samples?: number, metric?: string, algorithm?: string, n_jobs?: number | null);
+      fit(X: NDArray | PyProxy): Promise<DBSCAN>;
+      fit_predict(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly labels_: Promise<NDArray>;
+      readonly core_sample_indices_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class AgglomerativeClustering {
+      constructor(n_clusters?: number | null, linkage?: 'ward' | 'complete' | 'average' | 'single', affinity?: string);
+      fit(X: NDArray | PyProxy): Promise<AgglomerativeClustering>;
+      fit_predict(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly labels_: Promise<NDArray>;
+      readonly n_clusters_: Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class MeanShift {
+      constructor(bandwidth?: number | null, bin_seeding?: boolean, n_jobs?: number | null);
+      fit(X: NDArray | PyProxy): Promise<MeanShift>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly labels_: Promise<NDArray>;
+      readonly cluster_centers_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export class GaussianMixture {
+      constructor(n_components?: number, covariance_type?: string, max_iter?: number, random_state?: number | null);
+      fit(X: NDArray | PyProxy): Promise<GaussianMixture>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score_samples(X: NDArray | PyProxy): Promise<NDArray>;
+      readonly weights_: Promise<NDArray>;
+      readonly means_: Promise<NDArray>;
+      readonly covariances_: Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export function k_means(X: NDArray | PyProxy, n_clusters: number, random_state?: number | null): Promise<[NDArray, NDArray, number]>;
+  }
+
+  // ── sklearn.neighbors ────────────────────────────────────────────────────
+
+  export namespace neighbors {
+    export class KNeighborsClassifier {
+      constructor(n_neighbors?: number, weights?: 'uniform' | 'distance', algorithm?: string, metric?: string, n_jobs?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<KNeighborsClassifier>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      kneighbors(X?: NDArray | PyProxy | null, n_neighbors?: number): Promise<[NDArray, NDArray]>;
+      [key: string]: unknown;
+    }
+
+    export class KNeighborsRegressor {
+      constructor(n_neighbors?: number, weights?: 'uniform' | 'distance', algorithm?: string, metric?: string);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<KNeighborsRegressor>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      kneighbors(X?: NDArray | PyProxy | null, n_neighbors?: number): Promise<[NDArray, NDArray]>;
+      [key: string]: unknown;
+    }
+
+    export class NearestNeighbors {
+      constructor(n_neighbors?: number, algorithm?: string, metric?: string, n_jobs?: number | null);
+      fit(X: NDArray | PyProxy): Promise<NearestNeighbors>;
+      kneighbors(X?: NDArray | PyProxy | null, n_neighbors?: number, return_distance?: boolean): Promise<[NDArray, NDArray]>;
+      radius_neighbors(X?: NDArray | PyProxy | null, radius?: number): Promise<[NDArray, NDArray]>;
+      [key: string]: unknown;
+    }
+  }
+
+  // ── sklearn.naive_bayes ──────────────────────────────────────────────────
+
+  export namespace naive_bayes {
+    export class GaussianNB {
+      constructor(var_smoothing?: number);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<GaussianNB>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class MultinomialNB {
+      constructor(alpha?: number);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<MultinomialNB>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+
+    export class BernoulliNB {
+      constructor(alpha?: number, binarize?: number | null);
+      fit(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<BernoulliNB>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      [key: string]: unknown;
+    }
+  }
+
+  // ── sklearn.pipeline ─────────────────────────────────────────────────────
+
+  export namespace pipeline {
+    export class Pipeline {
+      constructor(steps: [string, PyProxy][], memory?: string | null, verbose?: boolean);
+      fit(X: NDArray | PyProxy, y?: NDArray | PyProxy | null): Promise<Pipeline>;
+      predict(X: NDArray | PyProxy): Promise<NDArray>;
+      predict_proba(X: NDArray | PyProxy): Promise<NDArray>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy, y?: NDArray | PyProxy | null): Promise<NDArray>;
+      score(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<number>;
+      get_params(deep?: boolean): Promise<Record<string, unknown>>;
+      set_params(params: Record<string, unknown>): Promise<Pipeline>;
+      readonly named_steps: Promise<Record<string, PyProxy>>;
+      readonly steps: Promise<[string, PyProxy][]>;
+      [key: string]: unknown;
+    }
+
+    export class FeatureUnion {
+      constructor(transformer_list: [string, PyProxy][], n_jobs?: number | null);
+      fit(X: NDArray | PyProxy, y?: NDArray | PyProxy | null): Promise<FeatureUnion>;
+      transform(X: NDArray | PyProxy): Promise<NDArray>;
+      fit_transform(X: NDArray | PyProxy, y?: NDArray | PyProxy | null): Promise<NDArray>;
+      [key: string]: unknown;
+    }
+
+    export function make_pipeline(...steps: PyProxy[]): Promise<Pipeline>;
+    export function make_union(...transformers: PyProxy[]): Promise<FeatureUnion>;
+  }
+
+  // ── sklearn.feature_extraction ───────────────────────────────────────────
+
+  export namespace feature_extraction {
+    export namespace text {
+      export class TfidfVectorizer {
+        constructor(max_features?: number | null, min_df?: number, max_df?: number, ngram_range?: [number, number], stop_words?: string | string[] | null, lowercase?: boolean, analyzer?: string);
+        fit(raw_documents: string[] | PyProxy): Promise<TfidfVectorizer>;
+        transform(raw_documents: string[] | PyProxy): Promise<PyProxy>;
+        fit_transform(raw_documents: string[] | PyProxy): Promise<PyProxy>;
+        get_feature_names_out(): Promise<string[]>;
+        get_feature_names(): Promise<string[]>;
+        readonly vocabulary_: Promise<Record<string, number>>;
+        readonly idf_: Promise<NDArray>;
+        [key: string]: unknown;
+      }
+
+      export class CountVectorizer {
+        constructor(max_features?: number | null, min_df?: number, max_df?: number, ngram_range?: [number, number], stop_words?: string | string[] | null, lowercase?: boolean);
+        fit(raw_documents: string[] | PyProxy): Promise<CountVectorizer>;
+        transform(raw_documents: string[] | PyProxy): Promise<PyProxy>;
+        fit_transform(raw_documents: string[] | PyProxy): Promise<PyProxy>;
+        get_feature_names_out(): Promise<string[]>;
+        readonly vocabulary_: Promise<Record<string, number>>;
+        [key: string]: unknown;
+      }
+
+      export class HashingVectorizer {
+        constructor(n_features?: number, ngram_range?: [number, number], lowercase?: boolean, analyzer?: string);
+        transform(raw_documents: string[] | PyProxy): Promise<PyProxy>;
+        fit_transform(raw_documents: string[] | PyProxy): Promise<PyProxy>;
+        [key: string]: unknown;
+      }
+    }
+  }
+
+  // ── sklearn utility functions ─────────────────────────────────────────────
+
+  export namespace utils {
+    export function check_array(array: NDArray | PyProxy, dtype?: string | null): Promise<NDArray>;
+    export function check_X_y(X: NDArray | PyProxy, y: NDArray | PyProxy): Promise<[NDArray, NDArray]>;
+    export function column_or_1d(y: NDArray | PyProxy): Promise<NDArray>;
+    export function shuffle(X: NDArray | PyProxy, y?: NDArray | PyProxy | null, random_state?: number | null): Promise<NDArray | [NDArray, NDArray]>;
+    export function resample(X: NDArray | PyProxy, y?: NDArray | PyProxy | null, n_samples?: number, random_state?: number | null): Promise<NDArray | [NDArray, NDArray]>;
+  }
+
+  export namespace externals {
+    export namespace joblib {
+      export function dump(obj: PyProxy, filename: string, compress?: number | boolean): Promise<string[]>;
+      export function load(filename: string): Promise<PyProxy>;
+    }
+  }
+
+  export const __version__: string;
+}
+