@elaraai/east-py-datascience 0.0.2-beta.8 → 0.0.2-beta.80

package/dist/src/scipy/scipy.d.ts

@@ -0,0 +1,2205 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * SciPy platform functions for East.
+ *
+ * Provides scientific computing utilities: statistics, optimization,
+ * interpolation, and curve fitting.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, IntegerType, BooleanType, FloatType, StringType, BlobType, NullType, FunctionType } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+export { VectorType, MatrixType, ScalarObjectiveType } from "../types.js";
+/**
+ * Optimization method for scipy.optimize.minimize.
+ */
+export declare const OptimizeMethodType: VariantType<{
+    /** BFGS algorithm */
+    readonly bfgs: NullType;
+    /** L-BFGS-B algorithm (default) */
+    readonly l_bfgs_b: NullType;
+    /** Nelder-Mead simplex */
+    readonly nelder_mead: NullType;
+    /** Powell's method */
+    readonly powell: NullType;
+    /** Conjugate gradient */
+    readonly cg: NullType;
+}>;
+/**
+ * Interpolation method for scipy.interpolate.interp1d.
+ */
+export declare const InterpolationKindType: VariantType<{
+    /** Linear interpolation (default) */
+    readonly linear: NullType;
+    /** Cubic interpolation */
+    readonly cubic: NullType;
+    /** Quadratic interpolation */
+    readonly quadratic: NullType;
+}>;
+/**
+ * Histogram bin selection method for numpy.histogram.
+ */
+export declare const HistogramBinMethodType: VariantType<{
+    /** Maximum of Sturges and FD estimators */
+    readonly auto: NullType;
+    /** Freedman-Diaconis estimator */
+    readonly fd: NullType;
+    /** Sturges estimator */
+    readonly sturges: NullType;
+    /** Scott's normal reference rule */
+    readonly scott: NullType;
+    /** Rice estimator */
+    readonly rice: NullType;
+    /** Square root estimator */
+    readonly sqrt: NullType;
+    /** Doane's estimator */
+    readonly doane: NullType;
+}>;
+/**
+ * Bandwidth selection method for KDE.
+ */
+export declare const KdeBandwidthMethodType: VariantType<{
+    /** Scott's rule of thumb (default) */
+    readonly scott: NullType;
+    /** Silverman's rule of thumb */
+    readonly silverman: NullType;
+}>;
+/**
+ * Configuration for scipy.optimize.minimize.
+ */
+export declare const OptimizeConfigType: StructType<{
+    /** Optimization method */
+    readonly method: OptionType<VariantType<{
+        /** BFGS algorithm */
+        readonly bfgs: NullType;
+        /** L-BFGS-B algorithm (default) */
+        readonly l_bfgs_b: NullType;
+        /** Nelder-Mead simplex */
+        readonly nelder_mead: NullType;
+        /** Powell's method */
+        readonly powell: NullType;
+        /** Conjugate gradient */
+        readonly cg: NullType;
+    }>>;
+    /** Maximum number of iterations */
+    readonly max_iter: OptionType<IntegerType>;
+    /** Tolerance for convergence */
+    readonly tol: OptionType<FloatType>;
+}>;
+/**
+ * Configuration for scipy.interpolate.interp1d.
+ */
+export declare const InterpolateConfigType: StructType<{
+    /** Interpolation method */
+    readonly kind: OptionType<VariantType<{
+        /** Linear interpolation (default) */
+        readonly linear: NullType;
+        /** Cubic interpolation */
+        readonly cubic: NullType;
+        /** Quadratic interpolation */
+        readonly quadratic: NullType;
+    }>>;
+}>;
+/**
+ * Parameter bounds for curve fitting.
+ */
+export declare const ParamBoundsType: StructType<{
+    /** Lower bounds for each parameter */
+    readonly lower: VectorType<FloatType>;
+    /** Upper bounds for each parameter */
+    readonly upper: VectorType<FloatType>;
+}>;
+/**
+ * Custom curve function type: (x: Float, params: Vector, fixed_params: Vector) -> Float
+ * The params are optimized, fixed_params are passed through unchanged.
+ * If no fixed_params provided in config, an empty vector is passed.
+ */
+export declare const CustomCurveFunctionType: FunctionType<[FloatType, VectorType<FloatType>, VectorType<FloatType>], FloatType>;
+/**
+ * Curve function type for scipy_curve_fit.
+ *
+ * Includes built-in standard mathematical functions and a custom option
+ * for user-defined functions.
+ */
+export declare const CurveFunctionType: VariantType<{
+    /** y = a * exp(-b * x), 2 params: [a, b] */
+    readonly exponential_decay: NullType;
+    /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
+    readonly exponential_with_offset: NullType;
+    /** y = a * exp(b * x), 2 params: [a, b] */
+    readonly exponential_growth: NullType;
+    /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
+    readonly logistic: NullType;
+    /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
+    readonly gompertz: NullType;
+    /** y = a * x^b, 2 params: [a, b] */
+    readonly power_law: NullType;
+    /** y = a + b * x, 2 params: [a, b] */
+    readonly linear: NullType;
+    /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
+    readonly quadratic: NullType;
+    /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
+    readonly cubic: NullType;
+    /** Custom function provided by user */
+    readonly custom: StructType<{
+        /** The curve function: (x, params, fixed_params) -> y */
+        readonly fn: FunctionType<[FloatType, VectorType<FloatType>, VectorType<FloatType>], FloatType>;
+        /** Number of parameters to optimize */
+        readonly n_params: IntegerType;
+        /** Optional parameter bounds */
+        readonly param_bounds: OptionType<StructType<{
+            /** Lower bounds for each parameter */
+            readonly lower: VectorType<FloatType>;
+            /** Upper bounds for each parameter */
+            readonly upper: VectorType<FloatType>;
+        }>>;
+        /** Optional fixed parameters passed to fn but not optimized */
+        readonly fixed_params: OptionType<VectorType<FloatType>>;
+    }>;
+}>;
+/**
+ * Configuration for curve fitting.
+ */
+export declare const CurveFitConfigType: StructType<{
+    /** Maximum number of function evaluations */
+    readonly max_iter: OptionType<IntegerType>;
+    /** Initial guess for parameters */
+    readonly initial_guess: OptionType<VectorType<FloatType>>;
+}>;
+/**
+ * Configuration for histogram computation.
+ */
+export declare const HistogramConfigType: StructType<{
+    /** Number of bins (default 10) */
+    readonly bins: OptionType<IntegerType>;
+    /** Auto bin method (overrides bins if set) */
+    readonly bin_method: OptionType<VariantType<{
+        /** Maximum of Sturges and FD estimators */
+        readonly auto: NullType;
+        /** Freedman-Diaconis estimator */
+        readonly fd: NullType;
+        /** Sturges estimator */
+        readonly sturges: NullType;
+        /** Scott's normal reference rule */
+        readonly scott: NullType;
+        /** Rice estimator */
+        readonly rice: NullType;
+        /** Square root estimator */
+        readonly sqrt: NullType;
+        /** Doane's estimator */
+        readonly doane: NullType;
+    }>>;
+    /** Lower bound */
+    readonly range_min: OptionType<FloatType>;
+    /** Upper bound */
+    readonly range_max: OptionType<FloatType>;
+    /** Normalize to probability density */
+    readonly density: OptionType<BooleanType>;
+    /** Per-element weights */
+    readonly weights: OptionType<VectorType<FloatType>>;
+}>;
+/**
+ * Configuration for Kernel Density Estimation.
+ */
+export declare const KdeConfigType: StructType<{
+    /** Bandwidth selection method (default scott) */
+    readonly bandwidth: OptionType<VariantType<{
+        /** Scott's rule of thumb (default) */
+        readonly scott: NullType;
+        /** Silverman's rule of thumb */
+        readonly silverman: NullType;
+    }>>;
+    /** Custom scalar bandwidth (overrides method if set) */
+    readonly bandwidth_scalar: OptionType<FloatType>;
+    /** Per-datapoint weights */
+    readonly weights: OptionType<VectorType<FloatType>>;
+}>;
+/**
+ * Configuration for quadratic optimization: f(x) = 0.5 * x'Ax + b'x + c
+ */
+export declare const QuadraticConfigType: StructType<{
+    /** Quadratic term (symmetric positive definite) */
+    readonly A: MatrixType<FloatType>;
+    /** Linear term */
+    readonly b: VectorType<FloatType>;
+    /** Constant term */
+    readonly c: FloatType;
+}>;
+/**
+ * Descriptive statistics result.
+ */
+export declare const StatsDescribeResultType: StructType<{
+    /** Number of observations */
+    readonly count: IntegerType;
+    /** Mean value */
+    readonly mean: FloatType;
+    /** Variance */
+    readonly variance: FloatType;
+    /** Skewness */
+    readonly skewness: FloatType;
+    /** Kurtosis */
+    readonly kurtosis: FloatType;
+    /** Minimum value */
+    readonly min: FloatType;
+    /** Maximum value */
+    readonly max: FloatType;
+}>;
+/**
+ * Robust statistics result (median-based, outlier-resistant).
+ */
+export declare const RobustStatsResultType: StructType<{
+    /** Median value */
+    readonly median: FloatType;
+    /** Interquartile range (Q3 - Q1) */
+    readonly iqr: FloatType;
+    /** Median absolute deviation */
+    readonly mad: FloatType;
+    /** 25th percentile */
+    readonly q1: FloatType;
+    /** 75th percentile */
+    readonly q3: FloatType;
+}>;
+/**
+ * Correlation result (Pearson or Spearman).
+ */
+export declare const CorrelationResultType: StructType<{
+    /** Correlation coefficient */
+    readonly correlation: FloatType;
+    /** P-value for hypothesis test */
+    readonly pvalue: FloatType;
+}>;
+/**
+ * Curve fitting result.
+ */
+export declare const CurveFitResultType: StructType<{
+    /** Fitted parameters */
+    readonly params: VectorType<FloatType>;
+    /** Whether fit converged */
+    readonly success: BooleanType;
+    /** Coefficient of determination (R²) */
+    readonly r_squared: FloatType;
+}>;
+/**
+ * Optimization result.
+ */
+export declare const OptimizeResultType: StructType<{
+    /** Optimal parameters */
+    readonly x: VectorType<FloatType>;
+    /** Function value at optimum */
+    readonly fun: FloatType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+    /** Number of iterations */
+    readonly nit: IntegerType;
+}>;
+/**
+ * Histogram computation result.
+ */
+export declare const HistogramResultType: StructType<{
+    /** Bin values (float to support density mode) */
+    readonly counts: VectorType<FloatType>;
+    /** Bin edges (length = len(counts) + 1) */
+    readonly bin_edges: VectorType<FloatType>;
+}>;
+/**
+ * KDE fitting result metadata.
+ */
+export declare const KdeResultType: StructType<{
+    /** Actual bandwidth factor used */
+    readonly bandwidth: FloatType;
+    /** Minimum of training data */
+    readonly data_min: FloatType;
+    /** Maximum of training data */
+    readonly data_max: FloatType;
+}>;
+/**
+ * Model blob type for scipy models.
+ */
+export declare const ScipyModelBlobType: VariantType<{
+    /** 1D interpolator (cloudpickle serialized) */
+    readonly scipy_interp_1d: StructType<{
+        /** Serialized interpolator */
+        readonly data: BlobType;
+        /** Interpolation method used */
+        readonly kind: VariantType<{
+            /** Linear interpolation (default) */
+            readonly linear: NullType;
+            /** Cubic interpolation */
+            readonly cubic: NullType;
+            /** Quadratic interpolation */
+            readonly quadratic: NullType;
+        }>;
+    }>;
+    /** KDE model (cloudpickle serialized) */
+    readonly scipy_kde: StructType<{
+        /** Serialized KDE model */
+        readonly data: BlobType;
+        /** KDE metadata */
+        readonly metadata: StructType<{
+            /** Actual bandwidth factor used */
+            readonly bandwidth: FloatType;
+            /** Minimum of training data */
+            readonly data_min: FloatType;
+            /** Maximum of training data */
+            readonly data_max: FloatType;
+        }>;
+    }>;
+}>;
+/**
+ * Bounds for dual annealing optimization (required).
+ */
+export declare const DualAnnealBoundsType: StructType<{
+    /** Lower bounds for each variable */
+    readonly lower: VectorType<FloatType>;
+    /** Upper bounds for each variable */
+    readonly upper: VectorType<FloatType>;
+}>;
+/**
+ * Configuration for scipy.optimize.dual_annealing.
+ *
+ * Combines generalized simulated annealing with local search.
+ * Much faster than pure Python simanneal for continuous optimization.
+ */
+export declare const DualAnnealConfigType: StructType<{
+    /** Maximum function evaluations (default: 1000) */
+    readonly maxfun: OptionType<IntegerType>;
+    /** Maximum iterations (default: 1000) */
+    readonly maxiter: OptionType<IntegerType>;
+    /** Initial temperature (default: 5230) */
+    readonly initial_temp: OptionType<FloatType>;
+    /** Temperature restart threshold (default: 2e-5) */
+    readonly restart_temp_ratio: OptionType<FloatType>;
+    /** Visiting distribution parameter (default: 2.62) */
+    readonly visit: OptionType<FloatType>;
+    /** Acceptance distribution parameter (default: -5.0) */
+    readonly accept: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly seed: OptionType<IntegerType>;
+    /** Disable local search for speed (default: false) */
+    readonly no_local_search: OptionType<BooleanType>;
+}>;
+/**
+ * Result from dual annealing optimization.
+ */
+export declare const DualAnnealResultType: StructType<{
+    /** Best solution found */
+    readonly x: VectorType<FloatType>;
+    /** Best objective value */
+    readonly fun: FloatType;
+    /** Number of function evaluations */
+    readonly nfev: IntegerType;
+    /** Number of iterations */
+    readonly nit: IntegerType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+    /** Status message */
+    readonly message: StringType;
+}>;
+/**
+ * Fit a parametric curve to data using nonlinear least squares.
+ */
+export declare const scipy_curve_fit: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** y = a * exp(-b * x), 2 params: [a, b] */
+    readonly exponential_decay: NullType;
+    /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
+    readonly exponential_with_offset: NullType;
+    /** y = a * exp(b * x), 2 params: [a, b] */
+    readonly exponential_growth: NullType;
+    /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
+    readonly logistic: NullType;
+    /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
+    readonly gompertz: NullType;
+    /** y = a * x^b, 2 params: [a, b] */
+    readonly power_law: NullType;
+    /** y = a + b * x, 2 params: [a, b] */
+    readonly linear: NullType;
+    /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
+    readonly quadratic: NullType;
+    /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
+    readonly cubic: NullType;
+    /** Custom function provided by user */
+    readonly custom: StructType<{
+        /** The curve function: (x, params, fixed_params) -> y */
+        readonly fn: FunctionType<[FloatType, VectorType<FloatType>, VectorType<FloatType>], FloatType>;
+        /** Number of parameters to optimize */
+        readonly n_params: IntegerType;
+        /** Optional parameter bounds */
+        readonly param_bounds: OptionType<StructType<{
+            /** Lower bounds for each parameter */
+            readonly lower: VectorType<FloatType>;
+            /** Upper bounds for each parameter */
+            readonly upper: VectorType<FloatType>;
+        }>>;
+        /** Optional fixed parameters passed to fn but not optimized */
+        readonly fixed_params: OptionType<VectorType<FloatType>>;
+    }>;
+}>, VectorType<FloatType>, VectorType<FloatType>, StructType<{
+    /** Maximum number of function evaluations */
+    readonly max_iter: OptionType<IntegerType>;
+    /** Initial guess for parameters */
+    readonly initial_guess: OptionType<VectorType<FloatType>>;
+}>], StructType<{
+    /** Fitted parameters */
+    readonly params: VectorType<FloatType>;
+    /** Whether fit converged */
+    readonly success: BooleanType;
+    /** Coefficient of determination (R²) */
+    readonly r_squared: FloatType;
+}>>;
+/**
+ * Compute descriptive statistics for data.
+ */
+export declare const scipy_stats_describe: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], StructType<{
+    /** Number of observations */
+    readonly count: IntegerType;
+    /** Mean value */
+    readonly mean: FloatType;
+    /** Variance */
+    readonly variance: FloatType;
+    /** Skewness */
+    readonly skewness: FloatType;
+    /** Kurtosis */
+    readonly kurtosis: FloatType;
+    /** Minimum value */
+    readonly min: FloatType;
+    /** Maximum value */
+    readonly max: FloatType;
+}>>;
+/**
+ * Compute Pearson correlation coefficient.
+ */
+export declare const scipy_stats_pearsonr: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>], StructType<{
+    /** Correlation coefficient */
+    readonly correlation: FloatType;
+    /** P-value for hypothesis test */
+    readonly pvalue: FloatType;
+}>>;
+/**
+ * Compute Spearman rank correlation.
+ */
+export declare const scipy_stats_spearmanr: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>], StructType<{
+    /** Correlation coefficient */
+    readonly correlation: FloatType;
+    /** P-value for hypothesis test */
+    readonly pvalue: FloatType;
+}>>;
+/**
+ * Compute percentiles of data.
+ * @param data - Input data vector
+ * @param percentiles - Percentile values to compute (0-100)
+ * @returns Values at the specified percentiles
+ */
+export declare const scipy_stats_percentile: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>], VectorType<FloatType>>;
+/**
+ * Compute the percentile rank of a score relative to a dataset.
+ * @param data - Reference data vector
+ * @param score - Value to compute the percentile rank for
+ * @returns Percentile rank (0-100)
+ */
+export declare const scipy_stats_percentileofscore: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, FloatType], FloatType>;
+/**
+ * Compute interquartile range (Q3 - Q1).
+ */
+export declare const scipy_stats_iqr: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], FloatType>;
+/**
+ * Compute median value.
+ */
+export declare const scipy_stats_median: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], FloatType>;
+/**
+ * Compute median absolute deviation (robust std estimate).
+ */
+export declare const scipy_stats_mad: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], FloatType>;
+/**
+ * Compute robust statistics in one call (median, iqr, mad, q1, q3).
+ */
+export declare const scipy_stats_robust: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], StructType<{
+    /** Median value */
+    readonly median: FloatType;
+    /** Interquartile range (Q3 - Q1) */
+    readonly iqr: FloatType;
+    /** Median absolute deviation */
+    readonly mad: FloatType;
+    /** 25th percentile */
+    readonly q1: FloatType;
+    /** 75th percentile */
+    readonly q3: FloatType;
+}>>;
+/**
+ * Fit 1D interpolator to data.
+ */
+export declare const scipy_interpolate_1d_fit: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>, StructType<{
+    /** Interpolation method */
+    readonly kind: OptionType<VariantType<{
+        /** Linear interpolation (default) */
+        readonly linear: NullType;
+        /** Cubic interpolation */
+        readonly cubic: NullType;
+        /** Quadratic interpolation */
+        readonly quadratic: NullType;
+    }>>;
+}>], VariantType<{
+    /** 1D interpolator (cloudpickle serialized) */
+    readonly scipy_interp_1d: StructType<{
+        /** Serialized interpolator */
+        readonly data: BlobType;
+        /** Interpolation method used */
+        readonly kind: VariantType<{
+            /** Linear interpolation (default) */
+            readonly linear: NullType;
+            /** Cubic interpolation */
+            readonly cubic: NullType;
+            /** Quadratic interpolation */
+            readonly quadratic: NullType;
+        }>;
+    }>;
+    /** KDE model (cloudpickle serialized) */
+    readonly scipy_kde: StructType<{
+        /** Serialized KDE model */
+        readonly data: BlobType;
+        /** KDE metadata */
+        readonly metadata: StructType<{
+            /** Actual bandwidth factor used */
+            readonly bandwidth: FloatType;
+            /** Minimum of training data */
+            readonly data_min: FloatType;
+            /** Maximum of training data */
+            readonly data_max: FloatType;
+        }>;
+    }>;
+}>>;
+/**
+ * Evaluate 1D interpolator at given points.
+ */
+export declare const scipy_interpolate_1d_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** 1D interpolator (cloudpickle serialized) */
+    readonly scipy_interp_1d: StructType<{
+        /** Serialized interpolator */
+        readonly data: BlobType;
+        /** Interpolation method used */
+        readonly kind: VariantType<{
+            /** Linear interpolation (default) */
+            readonly linear: NullType;
+            /** Cubic interpolation */
+            readonly cubic: NullType;
+            /** Quadratic interpolation */
+            readonly quadratic: NullType;
+        }>;
+    }>;
+    /** KDE model (cloudpickle serialized) */
+    readonly scipy_kde: StructType<{
+        /** Serialized KDE model */
+        readonly data: BlobType;
+        /** KDE metadata */
+        readonly metadata: StructType<{
+            /** Actual bandwidth factor used */
+            readonly bandwidth: FloatType;
+            /** Minimum of training data */
+            readonly data_min: FloatType;
+            /** Maximum of training data */
+            readonly data_max: FloatType;
+        }>;
+    }>;
+}>, VectorType<FloatType>], VectorType<FloatType>>;
+/**
+ * Minimize a scalar function using scipy.optimize.minimize.
+ */
+export declare const scipy_optimize_minimize: import("@elaraai/east").PlatformDefinition<[FunctionType<[VectorType<FloatType>], FloatType>, VectorType<FloatType>, StructType<{
+    /** Optimization method */
+    readonly method: OptionType<VariantType<{
+        /** BFGS algorithm */
+        readonly bfgs: NullType;
+        /** L-BFGS-B algorithm (default) */
+        readonly l_bfgs_b: NullType;
+        /** Nelder-Mead simplex */
+        readonly nelder_mead: NullType;
+        /** Powell's method */
+        readonly powell: NullType;
+        /** Conjugate gradient */
+        readonly cg: NullType;
+    }>>;
+    /** Maximum number of iterations */
+    readonly max_iter: OptionType<IntegerType>;
+    /** Tolerance for convergence */
+    readonly tol: OptionType<FloatType>;
+}>], StructType<{
+    /** Optimal parameters */
+    readonly x: VectorType<FloatType>;
+    /** Function value at optimum */
+    readonly fun: FloatType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+    /** Number of iterations */
+    readonly nit: IntegerType;
+}>>;
+/**
+ * Minimize a quadratic function with analytical gradient.
+ */
+export declare const scipy_optimize_minimize_quadratic: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, StructType<{
+    /** Quadratic term (symmetric positive definite) */
+    readonly A: MatrixType<FloatType>;
+    /** Linear term */
+    readonly b: VectorType<FloatType>;
+    /** Constant term */
+    readonly c: FloatType;
+}>, StructType<{
+    /** Optimization method */
+    readonly method: OptionType<VariantType<{
+        /** BFGS algorithm */
+        readonly bfgs: NullType;
+        /** L-BFGS-B algorithm (default) */
+        readonly l_bfgs_b: NullType;
+        /** Nelder-Mead simplex */
+        readonly nelder_mead: NullType;
+        /** Powell's method */
+        readonly powell: NullType;
+        /** Conjugate gradient */
+        readonly cg: NullType;
+    }>>;
+    /** Maximum number of iterations */
+    readonly max_iter: OptionType<IntegerType>;
+    /** Tolerance for convergence */
+    readonly tol: OptionType<FloatType>;
+}>], StructType<{
+    /** Optimal parameters */
+    readonly x: VectorType<FloatType>;
+    /** Function value at optimum */
+    readonly fun: FloatType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+    /** Number of iterations */
+    readonly nit: IntegerType;
+}>>;
+/**
+ * Global optimization using dual annealing.
+ *
+ * Combines generalized simulated annealing with local search.
+ * Much faster than simanneal for continuous optimization problems.
+ * Effective for non-convex problems with many local minima.
+ *
+ * @param objective_fn - Function to minimize: Vector -> Float
+ * @param x0 - Optional initial guess (if none, starts from bounds center)
+ * @param bounds - Required bounds for all variables
+ * @param config - Algorithm configuration
+ * @returns Optimization result with best solution
+ */
+export declare const scipy_optimize_dual_annealing: import("@elaraai/east").PlatformDefinition<[FunctionType<[VectorType<FloatType>], FloatType>, OptionType<VectorType<FloatType>>, StructType<{
+    /** Lower bounds for each variable */
+    readonly lower: VectorType<FloatType>;
+    /** Upper bounds for each variable */
+    readonly upper: VectorType<FloatType>;
+}>, StructType<{
+    /** Maximum function evaluations (default: 1000) */
+    readonly maxfun: OptionType<IntegerType>;
+    /** Maximum iterations (default: 1000) */
+    readonly maxiter: OptionType<IntegerType>;
+    /** Initial temperature (default: 5230) */
+    readonly initial_temp: OptionType<FloatType>;
+    /** Temperature restart threshold (default: 2e-5) */
+    readonly restart_temp_ratio: OptionType<FloatType>;
+    /** Visiting distribution parameter (default: 2.62) */
+    readonly visit: OptionType<FloatType>;
+    /** Acceptance distribution parameter (default: -5.0) */
+    readonly accept: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly seed: OptionType<IntegerType>;
+    /** Disable local search for speed (default: false) */
+    readonly no_local_search: OptionType<BooleanType>;
+}>], StructType<{
+    /** Best solution found */
+    readonly x: VectorType<FloatType>;
+    /** Best objective value */
+    readonly fun: FloatType;
+    /** Number of function evaluations */
+    readonly nfev: IntegerType;
+    /** Number of iterations */
+    readonly nit: IntegerType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+    /** Status message */
+    readonly message: StringType;
+}>>;
+/**
+ * Compute histogram of data using numpy.histogram.
+ */
+export declare const scipy_histogram: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, StructType<{
+    /** Number of bins (default 10) */
+    readonly bins: OptionType<IntegerType>;
+    /** Auto bin method (overrides bins if set) */
+    readonly bin_method: OptionType<VariantType<{
+        /** Maximum of Sturges and FD estimators */
+        readonly auto: NullType;
+        /** Freedman-Diaconis estimator */
+        readonly fd: NullType;
+        /** Sturges estimator */
+        readonly sturges: NullType;
+        /** Scott's normal reference rule */
+        readonly scott: NullType;
+        /** Rice estimator */
+        readonly rice: NullType;
+        /** Square root estimator */
+        readonly sqrt: NullType;
+        /** Doane's estimator */
+        readonly doane: NullType;
+    }>>;
+    /** Lower bound */
+    readonly range_min: OptionType<FloatType>;
+    /** Upper bound */
+    readonly range_max: OptionType<FloatType>;
+    /** Normalize to probability density */
+    readonly density: OptionType<BooleanType>;
+    /** Per-element weights */
+    readonly weights: OptionType<VectorType<FloatType>>;
+}>], StructType<{
+    /** Bin values (float to support density mode) */
+    readonly counts: VectorType<FloatType>;
+    /** Bin edges (length = len(counts) + 1) */
+    readonly bin_edges: VectorType<FloatType>;
+}>>;
+/**
+ * Fit a Kernel Density Estimator to data.
+ */
+export declare const scipy_kde_fit: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, StructType<{
+    /** Bandwidth selection method (default scott) */
+    readonly bandwidth: OptionType<VariantType<{
+        /** Scott's rule of thumb (default) */
+        readonly scott: NullType;
+        /** Silverman's rule of thumb */
+        readonly silverman: NullType;
+    }>>;
+    /** Custom scalar bandwidth (overrides method if set) */
+    readonly bandwidth_scalar: OptionType<FloatType>;
+    /** Per-datapoint weights */
+    readonly weights: OptionType<VectorType<FloatType>>;
+}>], VariantType<{
+    /** 1D interpolator (cloudpickle serialized) */
+    readonly scipy_interp_1d: StructType<{
+        /** Serialized interpolator */
+        readonly data: BlobType;
+        /** Interpolation method used */
+        readonly kind: VariantType<{
+            /** Linear interpolation (default) */
+            readonly linear: NullType;
+            /** Cubic interpolation */
+            readonly cubic: NullType;
+            /** Quadratic interpolation */
+            readonly quadratic: NullType;
+        }>;
+    }>;
+    /** KDE model (cloudpickle serialized) */
+    readonly scipy_kde: StructType<{
+        /** Serialized KDE model */
+        readonly data: BlobType;
+        /** KDE metadata */
+        readonly metadata: StructType<{
+            /** Actual bandwidth factor used */
+            readonly bandwidth: FloatType;
+            /** Minimum of training data */
+            readonly data_min: FloatType;
+            /** Maximum of training data */
+            readonly data_max: FloatType;
+        }>;
+    }>;
+}>>;
+/**
+ * Evaluate a fitted KDE model at given points.
+ */
+export declare const scipy_kde_evaluate: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** 1D interpolator (cloudpickle serialized) */
+    readonly scipy_interp_1d: StructType<{
+        /** Serialized interpolator */
+        readonly data: BlobType;
+        /** Interpolation method used */
+        readonly kind: VariantType<{
+            /** Linear interpolation (default) */
+            readonly linear: NullType;
+            /** Cubic interpolation */
+            readonly cubic: NullType;
+            /** Quadratic interpolation */
+            readonly quadratic: NullType;
+        }>;
+    }>;
+    /** KDE model (cloudpickle serialized) */
+    readonly scipy_kde: StructType<{
+        /** Serialized KDE model */
+        readonly data: BlobType;
+        /** KDE metadata */
+        readonly metadata: StructType<{
+            /** Actual bandwidth factor used */
+            readonly bandwidth: FloatType;
+            /** Minimum of training data */
+            readonly data_min: FloatType;
+            /** Maximum of training data */
+            readonly data_max: FloatType;
+        }>;
+    }>;
+}>, VectorType<FloatType>], VectorType<FloatType>>;
+/**
+ * Type definitions for scipy functions.
+ */
+export declare const ScipyTypes: {
+    readonly ScalarObjectiveType: FunctionType<[VectorType<FloatType>], FloatType>;
+    readonly OptimizeMethodType: VariantType<{
+        /** BFGS algorithm */
+        readonly bfgs: NullType;
+        /** L-BFGS-B algorithm (default) */
+        readonly l_bfgs_b: NullType;
+        /** Nelder-Mead simplex */
+        readonly nelder_mead: NullType;
+        /** Powell's method */
+        readonly powell: NullType;
+        /** Conjugate gradient */
+        readonly cg: NullType;
+    }>;
+    readonly InterpolationKindType: VariantType<{
+        /** Linear interpolation (default) */
+        readonly linear: NullType;
+        /** Cubic interpolation */
+        readonly cubic: NullType;
+        /** Quadratic interpolation */
+        readonly quadratic: NullType;
+    }>;
+    readonly HistogramBinMethodType: VariantType<{
+        /** Maximum of Sturges and FD estimators */
+        readonly auto: NullType;
+        /** Freedman-Diaconis estimator */
+        readonly fd: NullType;
+        /** Sturges estimator */
+        readonly sturges: NullType;
+        /** Scott's normal reference rule */
+        readonly scott: NullType;
+        /** Rice estimator */
+        readonly rice: NullType;
+        /** Square root estimator */
+        readonly sqrt: NullType;
+        /** Doane's estimator */
+        readonly doane: NullType;
+    }>;
+    readonly KdeBandwidthMethodType: VariantType<{
+        /** Scott's rule of thumb (default) */
+        readonly scott: NullType;
+        /** Silverman's rule of thumb */
+        readonly silverman: NullType;
+    }>;
+    readonly OptimizeConfigType: StructType<{
+        /** Optimization method */
+        readonly method: OptionType<VariantType<{
+            /** BFGS algorithm */
+            readonly bfgs: NullType;
+            /** L-BFGS-B algorithm (default) */
+            readonly l_bfgs_b: NullType;
+            /** Nelder-Mead simplex */
+            readonly nelder_mead: NullType;
+            /** Powell's method */
+            readonly powell: NullType;
+            /** Conjugate gradient */
+            readonly cg: NullType;
+        }>>;
+        /** Maximum number of iterations */
+        readonly max_iter: OptionType<IntegerType>;
+        /** Tolerance for convergence */
+        readonly tol: OptionType<FloatType>;
+    }>;
+    readonly InterpolateConfigType: StructType<{
+        /** Interpolation method */
+        readonly kind: OptionType<VariantType<{
+            /** Linear interpolation (default) */
+            readonly linear: NullType;
+            /** Cubic interpolation */
+            readonly cubic: NullType;
+            /** Quadratic interpolation */
+            readonly quadratic: NullType;
+        }>>;
+    }>;
+    readonly HistogramConfigType: StructType<{
+        /** Number of bins (default 10) */
+        readonly bins: OptionType<IntegerType>;
+        /** Auto bin method (overrides bins if set) */
+        readonly bin_method: OptionType<VariantType<{
+            /** Maximum of Sturges and FD estimators */
+            readonly auto: NullType;
+            /** Freedman-Diaconis estimator */
+            readonly fd: NullType;
+            /** Sturges estimator */
+            readonly sturges: NullType;
+            /** Scott's normal reference rule */
+            readonly scott: NullType;
+            /** Rice estimator */
+            readonly rice: NullType;
+            /** Square root estimator */
+            readonly sqrt: NullType;
+            /** Doane's estimator */
+            readonly doane: NullType;
+        }>>;
+        /** Lower bound */
+        readonly range_min: OptionType<FloatType>;
+        /** Upper bound */
+        readonly range_max: OptionType<FloatType>;
+        /** Normalize to probability density */
+        readonly density: OptionType<BooleanType>;
+        /** Per-element weights */
+        readonly weights: OptionType<VectorType<FloatType>>;
+    }>;
+    readonly KdeConfigType: StructType<{
+        /** Bandwidth selection method (default scott) */
+        readonly bandwidth: OptionType<VariantType<{
+            /** Scott's rule of thumb (default) */
+            readonly scott: NullType;
+            /** Silverman's rule of thumb */
+            readonly silverman: NullType;
+        }>>;
+        /** Custom scalar bandwidth (overrides method if set) */
+        readonly bandwidth_scalar: OptionType<FloatType>;
+        /** Per-datapoint weights */
+        readonly weights: OptionType<VectorType<FloatType>>;
+    }>;
+    readonly ParamBoundsType: StructType<{
+        /** Lower bounds for each parameter */
+        readonly lower: VectorType<FloatType>;
+        /** Upper bounds for each parameter */
+        readonly upper: VectorType<FloatType>;
+    }>;
+    readonly CustomCurveFunctionType: FunctionType<[FloatType, VectorType<FloatType>, VectorType<FloatType>], FloatType>;
+    readonly CurveFunctionType: VariantType<{
+        /** y = a * exp(-b * x), 2 params: [a, b] */
+        readonly exponential_decay: NullType;
+        /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
+        readonly exponential_with_offset: NullType;
+        /** y = a * exp(b * x), 2 params: [a, b] */
+        readonly exponential_growth: NullType;
+        /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
+        readonly logistic: NullType;
+        /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
+        readonly gompertz: NullType;
+        /** y = a * x^b, 2 params: [a, b] */
+        readonly power_law: NullType;
+        /** y = a + b * x, 2 params: [a, b] */
+        readonly linear: NullType;
+        /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
+        readonly quadratic: NullType;
+        /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
+        readonly cubic: NullType;
+        /** Custom function provided by user */
+        readonly custom: StructType<{
+            /** The curve function: (x, params, fixed_params) -> y */
+            readonly fn: FunctionType<[FloatType, VectorType<FloatType>, VectorType<FloatType>], FloatType>;
+            /** Number of parameters to optimize */
+            readonly n_params: IntegerType;
+            /** Optional parameter bounds */
+            readonly param_bounds: OptionType<StructType<{
+                /** Lower bounds for each parameter */
+                readonly lower: VectorType<FloatType>;
+                /** Upper bounds for each parameter */
+                readonly upper: VectorType<FloatType>;
+            }>>;
+            /** Optional fixed parameters passed to fn but not optimized */
+            readonly fixed_params: OptionType<VectorType<FloatType>>;
+        }>;
+    }>;
+    readonly CurveFitConfigType: StructType<{
+        /** Maximum number of function evaluations */
+        readonly max_iter: OptionType<IntegerType>;
+        /** Initial guess for parameters */
+        readonly initial_guess: OptionType<VectorType<FloatType>>;
+    }>;
+    readonly QuadraticConfigType: StructType<{
+        /** Quadratic term (symmetric positive definite) */
+        readonly A: MatrixType<FloatType>;
+        /** Linear term */
+        readonly b: VectorType<FloatType>;
+        /** Constant term */
+        readonly c: FloatType;
+    }>;
+    readonly StatsDescribeResultType: StructType<{
+        /** Number of observations */
+        readonly count: IntegerType;
+        /** Mean value */
+        readonly mean: FloatType;
+        /** Variance */
+        readonly variance: FloatType;
+        /** Skewness */
+        readonly skewness: FloatType;
+        /** Kurtosis */
+        readonly kurtosis: FloatType;
+        /** Minimum value */
+        readonly min: FloatType;
+        /** Maximum value */
+        readonly max: FloatType;
+    }>;
+    readonly RobustStatsResultType: StructType<{
+        /** Median value */
+        readonly median: FloatType;
+        /** Interquartile range (Q3 - Q1) */
+        readonly iqr: FloatType;
+        /** Median absolute deviation */
+        readonly mad: FloatType;
+        /** 25th percentile */
+        readonly q1: FloatType;
+        /** 75th percentile */
+        readonly q3: FloatType;
+    }>;
+    readonly CorrelationResultType: StructType<{
+        /** Correlation coefficient */
+        readonly correlation: FloatType;
+        /** P-value for hypothesis test */
+        readonly pvalue: FloatType;
+    }>;
+    readonly CurveFitResultType: StructType<{
+        /** Fitted parameters */
+        readonly params: VectorType<FloatType>;
+        /** Whether fit converged */
+        readonly success: BooleanType;
+        /** Coefficient of determination (R²) */
+        readonly r_squared: FloatType;
+    }>;
+    readonly OptimizeResultType: StructType<{
+        /** Optimal parameters */
+        readonly x: VectorType<FloatType>;
+        /** Function value at optimum */
+        readonly fun: FloatType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+        /** Number of iterations */
+        readonly nit: IntegerType;
+    }>;
+    readonly HistogramResultType: StructType<{
+        /** Bin values (float to support density mode) */
+        readonly counts: VectorType<FloatType>;
+        /** Bin edges (length = len(counts) + 1) */
+        readonly bin_edges: VectorType<FloatType>;
+    }>;
+    readonly KdeResultType: StructType<{
+        /** Actual bandwidth factor used */
+        readonly bandwidth: FloatType;
+        /** Minimum of training data */
+        readonly data_min: FloatType;
+        /** Maximum of training data */
+        readonly data_max: FloatType;
+    }>;
+    readonly ModelBlobType: VariantType<{
+        /** 1D interpolator (cloudpickle serialized) */
+        readonly scipy_interp_1d: StructType<{
+            /** Serialized interpolator */
+            readonly data: BlobType;
+            /** Interpolation method used */
+            readonly kind: VariantType<{
+                /** Linear interpolation (default) */
+                readonly linear: NullType;
+                /** Cubic interpolation */
+                readonly cubic: NullType;
+                /** Quadratic interpolation */
+                readonly quadratic: NullType;
+            }>;
+        }>;
+        /** KDE model (cloudpickle serialized) */
+        readonly scipy_kde: StructType<{
+            /** Serialized KDE model */
+            readonly data: BlobType;
+            /** KDE metadata */
+            readonly metadata: StructType<{
+                /** Actual bandwidth factor used */
+                readonly bandwidth: FloatType;
+                /** Minimum of training data */
+                readonly data_min: FloatType;
+                /** Maximum of training data */
+                readonly data_max: FloatType;
+            }>;
+        }>;
+    }>;
+    readonly DualAnnealBoundsType: StructType<{
+        /** Lower bounds for each variable */
+        readonly lower: VectorType<FloatType>;
+        /** Upper bounds for each variable */
+        readonly upper: VectorType<FloatType>;
+    }>;
+    readonly DualAnnealConfigType: StructType<{
+        /** Maximum function evaluations (default: 1000) */
+        readonly maxfun: OptionType<IntegerType>;
+        /** Maximum iterations (default: 1000) */
+        readonly maxiter: OptionType<IntegerType>;
+        /** Initial temperature (default: 5230) */
+        readonly initial_temp: OptionType<FloatType>;
+        /** Temperature restart threshold (default: 2e-5) */
+        readonly restart_temp_ratio: OptionType<FloatType>;
+        /** Visiting distribution parameter (default: 2.62) */
+        readonly visit: OptionType<FloatType>;
+        /** Acceptance distribution parameter (default: -5.0) */
+        readonly accept: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly seed: OptionType<IntegerType>;
+        /** Disable local search for speed (default: false) */
+        readonly no_local_search: OptionType<BooleanType>;
+    }>;
+    readonly DualAnnealResultType: StructType<{
+        /** Best solution found */
+        readonly x: VectorType<FloatType>;
+        /** Best objective value */
+        readonly fun: FloatType;
+        /** Number of function evaluations */
+        readonly nfev: IntegerType;
+        /** Number of iterations */
+        readonly nit: IntegerType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+        /** Status message */
+        readonly message: StringType;
+    }>;
+};
+/**
+ * SciPy scientific computing utilities.
+ *
+ * Provides statistics, optimization, interpolation, and curve fitting.
+ */
+export declare const Scipy: {
+    /**
+     * Fit a parametric curve to data using nonlinear least squares.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Scipy, VectorType, CurveFitConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const fit = East.function(
+     *     [VectorType(FloatType), VectorType(FloatType)],
+     *     Scipy.Types.CurveFitResultType,
+     *     ($, x, y) => {
+     *         const func = $.let(variant("exponential_decay", null), Scipy.Types.CurveFunctionType);
+     *         const config = $.let({
+     *             max_iter: variant("none", null),
+     *             initial_guess: variant("none", null),
+     *         }, CurveFitConfigType);
+     *         return $.return(Scipy.curveFit(func, x, y, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly curveFit: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** y = a * exp(-b * x), 2 params: [a, b] */
+        readonly exponential_decay: NullType;
+        /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
+        readonly exponential_with_offset: NullType;
+        /** y = a * exp(b * x), 2 params: [a, b] */
+        readonly exponential_growth: NullType;
+        /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
+        readonly logistic: NullType;
+        /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
+        readonly gompertz: NullType;
+        /** y = a * x^b, 2 params: [a, b] */
+        readonly power_law: NullType;
+        /** y = a + b * x, 2 params: [a, b] */
+        readonly linear: NullType;
+        /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
+        readonly quadratic: NullType;
+        /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
+        readonly cubic: NullType;
+        /** Custom function provided by user */
+        readonly custom: StructType<{
+            /** The curve function: (x, params, fixed_params) -> y */
+            readonly fn: FunctionType<[FloatType, VectorType<FloatType>, VectorType<FloatType>], FloatType>;
+            /** Number of parameters to optimize */
+            readonly n_params: IntegerType;
+            /** Optional parameter bounds */
+            readonly param_bounds: OptionType<StructType<{
+                /** Lower bounds for each parameter */
+                readonly lower: VectorType<FloatType>;
+                /** Upper bounds for each parameter */
+                readonly upper: VectorType<FloatType>;
+            }>>;
+            /** Optional fixed parameters passed to fn but not optimized */
+            readonly fixed_params: OptionType<VectorType<FloatType>>;
+        }>;
+    }>, VectorType<FloatType>, VectorType<FloatType>, StructType<{
+        /** Maximum number of function evaluations */
+        readonly max_iter: OptionType<IntegerType>;
+        /** Initial guess for parameters */
+        readonly initial_guess: OptionType<VectorType<FloatType>>;
+    }>], StructType<{
+        /** Fitted parameters */
+        readonly params: VectorType<FloatType>;
+        /** Whether fit converged */
+        readonly success: BooleanType;
+        /** Coefficient of determination (R²) */
+        readonly r_squared: FloatType;
+    }>>;
+    /**
+     * Compute descriptive statistics for data.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const describe = East.function(
+     *     [VectorType(FloatType)],
+     *     Scipy.Types.StatsDescribeResultType,
+     *     ($, data) => {
+     *         const result = $.let(Scipy.statsDescribe(data));
+     *         // result.mean, result.variance, result.skewness, etc.
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly statsDescribe: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], StructType<{
+        /** Number of observations */
+        readonly count: IntegerType;
+        /** Mean value */
+        readonly mean: FloatType;
+        /** Variance */
+        readonly variance: FloatType;
+        /** Skewness */
+        readonly skewness: FloatType;
+        /** Kurtosis */
+        readonly kurtosis: FloatType;
+        /** Minimum value */
+        readonly min: FloatType;
+        /** Maximum value */
+        readonly max: FloatType;
+    }>>;
+    /**
+     * Compute Pearson correlation coefficient.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const correlate = East.function(
+     *     [VectorType(FloatType), VectorType(FloatType)],
+     *     Scipy.Types.CorrelationResultType,
+     *     ($, x, y) => {
+     *         const result = $.let(Scipy.statsPearsonr(x, y));
+     *         // result.correlation, result.pvalue
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly statsPearsonr: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>], StructType<{
+        /** Correlation coefficient */
+        readonly correlation: FloatType;
+        /** P-value for hypothesis test */
+        readonly pvalue: FloatType;
+    }>>;
+    /**
+     * Compute Spearman rank correlation.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const correlate = East.function(
+     *     [VectorType(FloatType), VectorType(FloatType)],
+     *     Scipy.Types.CorrelationResultType,
+     *     ($, x, y) => {
+     *         const result = $.let(Scipy.statsSpearmanr(x, y));
+     *         // result.correlation, result.pvalue
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly statsSpearmanr: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>], StructType<{
+        /** Correlation coefficient */
+        readonly correlation: FloatType;
+        /** P-value for hypothesis test */
+        readonly pvalue: FloatType;
+    }>>;
+    /**
+     * Compute percentiles of data.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const getPercentiles = East.function(
+     *     [VectorType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, data) => {
+     *         const percentiles = $.let(new Float64Array([25.0, 50.0, 75.0]));
+     *         return $.return(Scipy.statsPercentile(data, percentiles));
+     *     }
+     * );
+     * ```
+     */
+    readonly statsPercentile: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>], VectorType<FloatType>>;
+    /**
+     * Compute the percentile rank of a score relative to a dataset.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const getPctRank = East.function(
+     *     [VectorType(FloatType), FloatType],
+     *     FloatType,
+     *     ($, data, score) => {
+     *         return $.return(Scipy.statsPercentileOfScore(data, score));
+     *     }
+     * );
+     * ```
+     */
+    readonly statsPercentileOfScore: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, FloatType], FloatType>;
+    /**
+     * Compute interquartile range (Q3 - Q1).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const getIqr = East.function(
+     *     [VectorType(FloatType)],
+     *     FloatType,
+     *     ($, data) => {
+     *         return $.return(Scipy.statsIqr(data));
+     *     }
+     * );
+     * ```
+     */
+    readonly statsIqr: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], FloatType>;
+    /**
+     * Compute median value.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const getMedian = East.function(
+     *     [VectorType(FloatType)],
+     *     FloatType,
+     *     ($, data) => {
+     *         return $.return(Scipy.statsMedian(data));
+     *     }
+     * );
+     * ```
+     */
+    readonly statsMedian: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], FloatType>;
+    /**
+     * Compute median absolute deviation (robust std estimate).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const getMad = East.function(
+     *     [VectorType(FloatType)],
+     *     FloatType,
+     *     ($, data) => {
+     *         return $.return(Scipy.statsMad(data));
+     *     }
+     * );
+     * ```
+     */
+    readonly statsMad: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], FloatType>;
+    /**
+     * Compute robust statistics in one call (median, iqr, mad, q1, q3).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const getRobust = East.function(
+     *     [VectorType(FloatType)],
+     *     Scipy.Types.RobustStatsResultType,
+     *     ($, data) => {
+     *         const result = $.let(Scipy.statsRobust(data));
+     *         // result.median, result.iqr, result.mad, result.q1, result.q3
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly statsRobust: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>], StructType<{
+        /** Median value */
+        readonly median: FloatType;
+        /** Interquartile range (Q3 - Q1) */
+        readonly iqr: FloatType;
+        /** Median absolute deviation */
+        readonly mad: FloatType;
+        /** 25th percentile */
+        readonly q1: FloatType;
+        /** 75th percentile */
+        readonly q3: FloatType;
+    }>>;
+    /**
+     * Fit a 1D interpolator to data.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Scipy, VectorType, InterpolateConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const fitInterp = East.function(
+     *     [VectorType(FloatType), VectorType(FloatType)],
+     *     Scipy.Types.ModelBlobType,
+     *     ($, x, y) => {
+     *         const config = $.let({
+     *             kind: variant("some", variant("cubic", null)),
+     *         }, InterpolateConfigType);
+     *         return $.return(Scipy.interpolate1dFit(x, y, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly interpolate1dFit: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, VectorType<FloatType>, StructType<{
+        /** Interpolation method */
+        readonly kind: OptionType<VariantType<{
+            /** Linear interpolation (default) */
+            readonly linear: NullType;
+            /** Cubic interpolation */
+            readonly cubic: NullType;
+            /** Quadratic interpolation */
+            readonly quadratic: NullType;
+        }>>;
+    }>], VariantType<{
+        /** 1D interpolator (cloudpickle serialized) */
+        readonly scipy_interp_1d: StructType<{
+            /** Serialized interpolator */
+            readonly data: BlobType;
+            /** Interpolation method used */
+            readonly kind: VariantType<{
+                /** Linear interpolation (default) */
+                readonly linear: NullType;
+                /** Cubic interpolation */
+                readonly cubic: NullType;
+                /** Quadratic interpolation */
+                readonly quadratic: NullType;
+            }>;
+        }>;
+        /** KDE model (cloudpickle serialized) */
+        readonly scipy_kde: StructType<{
+            /** Serialized KDE model */
+            readonly data: BlobType;
+            /** KDE metadata */
+            readonly metadata: StructType<{
+                /** Actual bandwidth factor used */
+                readonly bandwidth: FloatType;
+                /** Minimum of training data */
+                readonly data_min: FloatType;
+                /** Maximum of training data */
+                readonly data_max: FloatType;
+            }>;
+        }>;
+    }>>;
+    /**
+     * Evaluate a fitted 1D interpolator at given points.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const predict = East.function(
+     *     [Scipy.Types.ModelBlobType, VectorType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, x_new) => {
+     *         return $.return(Scipy.interpolate1dPredict(model, x_new));
+     *     }
+     * );
+     * ```
+     */
+    readonly interpolate1dPredict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** 1D interpolator (cloudpickle serialized) */
+        readonly scipy_interp_1d: StructType<{
+            /** Serialized interpolator */
+            readonly data: BlobType;
+            /** Interpolation method used */
+            readonly kind: VariantType<{
+                /** Linear interpolation (default) */
+                readonly linear: NullType;
+                /** Cubic interpolation */
+                readonly cubic: NullType;
+                /** Quadratic interpolation */
+                readonly quadratic: NullType;
+            }>;
+        }>;
+        /** KDE model (cloudpickle serialized) */
+        readonly scipy_kde: StructType<{
+            /** Serialized KDE model */
+            readonly data: BlobType;
+            /** KDE metadata */
+            readonly metadata: StructType<{
+                /** Actual bandwidth factor used */
+                readonly bandwidth: FloatType;
+                /** Minimum of training data */
+                readonly data_min: FloatType;
+                /** Maximum of training data */
+                readonly data_max: FloatType;
+            }>;
+        }>;
+    }>, VectorType<FloatType>], VectorType<FloatType>>;
+    /**
+     * Minimize a scalar function using scipy.optimize.minimize.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Scipy, VectorType, ScalarObjectiveType, OptimizeConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const optimize = East.function(
+     *     [ScalarObjectiveType, VectorType(FloatType)],
+     *     Scipy.Types.OptimizeResultType,
+     *     ($, objective, x0) => {
+     *         const config = $.let({
+     *             method: variant("some", variant("l_bfgs_b", null)),
+     *             max_iter: variant("some", 100n),
+     *             tol: variant("none", null),
+     *         }, OptimizeConfigType);
+     *         return $.return(Scipy.optimizeMinimize(objective, x0, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly optimizeMinimize: import("@elaraai/east").PlatformDefinition<[FunctionType<[VectorType<FloatType>], FloatType>, VectorType<FloatType>, StructType<{
+        /** Optimization method */
+        readonly method: OptionType<VariantType<{
+            /** BFGS algorithm */
+            readonly bfgs: NullType;
+            /** L-BFGS-B algorithm (default) */
+            readonly l_bfgs_b: NullType;
+            /** Nelder-Mead simplex */
+            readonly nelder_mead: NullType;
+            /** Powell's method */
+            readonly powell: NullType;
+            /** Conjugate gradient */
+            readonly cg: NullType;
+        }>>;
+        /** Maximum number of iterations */
+        readonly max_iter: OptionType<IntegerType>;
+        /** Tolerance for convergence */
+        readonly tol: OptionType<FloatType>;
+    }>], StructType<{
+        /** Optimal parameters */
+        readonly x: VectorType<FloatType>;
+        /** Function value at optimum */
+        readonly fun: FloatType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+        /** Number of iterations */
+        readonly nit: IntegerType;
+    }>>;
+    /**
+     * Minimize a quadratic function with analytical gradient.
+     *
+     * Minimizes f(x) = 0.5 * x'Ax + b'x + c.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Scipy, VectorType, MatrixType, QuadraticConfigType, OptimizeConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const optimize = East.function(
+     *     [VectorType(FloatType)],
+     *     Scipy.Types.OptimizeResultType,
+     *     ($, x0) => {
+     *         const quadConfig = $.let({
+     *             A: [[2.0, 0.0], [0.0, 2.0]],
+     *             b: new Float64Array([-4.0, -6.0]),
+     *             c: 0.0,
+     *         }, QuadraticConfigType);
+     *         const config = $.let({
+     *             method: variant("some", variant("l_bfgs_b", null)),
+     *             max_iter: variant("none", null),
+     *             tol: variant("none", null),
+     *         }, OptimizeConfigType);
+     *         return $.return(Scipy.optimizeMinimizeQuadratic(x0, quadConfig, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly optimizeMinimizeQuadratic: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, StructType<{
+        /** Quadratic term (symmetric positive definite) */
+        readonly A: MatrixType<FloatType>;
+        /** Linear term */
+        readonly b: VectorType<FloatType>;
+        /** Constant term */
+        readonly c: FloatType;
+    }>, StructType<{
+        /** Optimization method */
+        readonly method: OptionType<VariantType<{
+            /** BFGS algorithm */
+            readonly bfgs: NullType;
+            /** L-BFGS-B algorithm (default) */
+            readonly l_bfgs_b: NullType;
+            /** Nelder-Mead simplex */
+            readonly nelder_mead: NullType;
+            /** Powell's method */
+            readonly powell: NullType;
+            /** Conjugate gradient */
+            readonly cg: NullType;
+        }>>;
+        /** Maximum number of iterations */
+        readonly max_iter: OptionType<IntegerType>;
+        /** Tolerance for convergence */
+        readonly tol: OptionType<FloatType>;
+    }>], StructType<{
+        /** Optimal parameters */
+        readonly x: VectorType<FloatType>;
+        /** Function value at optimum */
+        readonly fun: FloatType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+        /** Number of iterations */
+        readonly nit: IntegerType;
+    }>>;
+    /**
+     * Global optimization using dual annealing.
+     *
+     * Combines generalized simulated annealing with local search.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Scipy, VectorType, ScalarObjectiveType, DualAnnealBoundsType, DualAnnealConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const optimize = East.function(
+     *     [ScalarObjectiveType],
+     *     Scipy.Types.DualAnnealResultType,
+     *     ($, objective) => {
+     *         const bounds = $.let({
+     *             lower: new Float64Array([-5.0, -5.0]),
+     *             upper: new Float64Array([5.0, 5.0]),
+     *         }, DualAnnealBoundsType);
+     *         const config = $.let({
+     *             maxfun: variant("some", 1000n),
+     *             maxiter: variant("none", null),
+     *             initial_temp: variant("none", null),
+     *             restart_temp_ratio: variant("none", null),
+     *             visit: variant("none", null),
+     *             accept: variant("none", null),
+     *             seed: variant("some", 42n),
+     *             no_local_search: variant("none", null),
+     *         }, DualAnnealConfigType);
+     *         return $.return(Scipy.optimizeDualAnnealing(objective, variant("none", null), bounds, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly optimizeDualAnnealing: import("@elaraai/east").PlatformDefinition<[FunctionType<[VectorType<FloatType>], FloatType>, OptionType<VectorType<FloatType>>, StructType<{
+        /** Lower bounds for each variable */
+        readonly lower: VectorType<FloatType>;
+        /** Upper bounds for each variable */
+        readonly upper: VectorType<FloatType>;
+    }>, StructType<{
+        /** Maximum function evaluations (default: 1000) */
+        readonly maxfun: OptionType<IntegerType>;
+        /** Maximum iterations (default: 1000) */
+        readonly maxiter: OptionType<IntegerType>;
+        /** Initial temperature (default: 5230) */
+        readonly initial_temp: OptionType<FloatType>;
+        /** Temperature restart threshold (default: 2e-5) */
+        readonly restart_temp_ratio: OptionType<FloatType>;
+        /** Visiting distribution parameter (default: 2.62) */
+        readonly visit: OptionType<FloatType>;
+        /** Acceptance distribution parameter (default: -5.0) */
+        readonly accept: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly seed: OptionType<IntegerType>;
+        /** Disable local search for speed (default: false) */
+        readonly no_local_search: OptionType<BooleanType>;
+    }>], StructType<{
+        /** Best solution found */
+        readonly x: VectorType<FloatType>;
+        /** Best objective value */
+        readonly fun: FloatType;
+        /** Number of function evaluations */
+        readonly nfev: IntegerType;
+        /** Number of iterations */
+        readonly nit: IntegerType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+        /** Status message */
+        readonly message: StringType;
+    }>>;
+    /**
+     * Compute histogram of data.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Scipy, VectorType, HistogramConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const computeHist = East.function(
+     *     [VectorType(FloatType)],
+     *     Scipy.Types.HistogramResultType,
+     *     ($, data) => {
+     *         const config = $.let({
+     *             bins: variant("some", 20n),
+     *             bin_method: variant("none", null),
+     *             range_min: variant("none", null),
+     *             range_max: variant("none", null),
+     *             density: variant("some", true),
+     *             weights: variant("none", null),
+     *         }, HistogramConfigType);
+     *         const result = $.let(Scipy.histogram(data, config));
+     *         // result.counts, result.bin_edges
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly histogram: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, StructType<{
+        /** Number of bins (default 10) */
+        readonly bins: OptionType<IntegerType>;
+        /** Auto bin method (overrides bins if set) */
+        readonly bin_method: OptionType<VariantType<{
+            /** Maximum of Sturges and FD estimators */
+            readonly auto: NullType;
+            /** Freedman-Diaconis estimator */
+            readonly fd: NullType;
+            /** Sturges estimator */
+            readonly sturges: NullType;
+            /** Scott's normal reference rule */
+            readonly scott: NullType;
+            /** Rice estimator */
+            readonly rice: NullType;
+            /** Square root estimator */
+            readonly sqrt: NullType;
+            /** Doane's estimator */
+            readonly doane: NullType;
+        }>>;
+        /** Lower bound */
+        readonly range_min: OptionType<FloatType>;
+        /** Upper bound */
+        readonly range_max: OptionType<FloatType>;
+        /** Normalize to probability density */
+        readonly density: OptionType<BooleanType>;
+        /** Per-element weights */
+        readonly weights: OptionType<VectorType<FloatType>>;
+    }>], StructType<{
+        /** Bin values (float to support density mode) */
+        readonly counts: VectorType<FloatType>;
+        /** Bin edges (length = len(counts) + 1) */
+        readonly bin_edges: VectorType<FloatType>;
+    }>>;
+    /**
+     * Fit a Kernel Density Estimator to data.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { Scipy, VectorType, KdeConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const fitKde = East.function(
+     *     [VectorType(FloatType)],
+     *     Scipy.Types.ModelBlobType,
+     *     ($, data) => {
+     *         const config = $.let({
+     *             bandwidth: variant("some", variant("scott", null)),
+     *             bandwidth_scalar: variant("none", null),
+     *             weights: variant("none", null),
+     *         }, KdeConfigType);
+     *         return $.return(Scipy.kdeFit(data, config));
+     *     }
+     * );
+     * ```
+     */
+    readonly kdeFit: import("@elaraai/east").PlatformDefinition<[VectorType<FloatType>, StructType<{
+        /** Bandwidth selection method (default scott) */
+        readonly bandwidth: OptionType<VariantType<{
+            /** Scott's rule of thumb (default) */
+            readonly scott: NullType;
+            /** Silverman's rule of thumb */
+            readonly silverman: NullType;
+        }>>;
+        /** Custom scalar bandwidth (overrides method if set) */
+        readonly bandwidth_scalar: OptionType<FloatType>;
+        /** Per-datapoint weights */
+        readonly weights: OptionType<VectorType<FloatType>>;
+    }>], VariantType<{
+        /** 1D interpolator (cloudpickle serialized) */
+        readonly scipy_interp_1d: StructType<{
+            /** Serialized interpolator */
+            readonly data: BlobType;
+            /** Interpolation method used */
+            readonly kind: VariantType<{
+                /** Linear interpolation (default) */
+                readonly linear: NullType;
+                /** Cubic interpolation */
+                readonly cubic: NullType;
+                /** Quadratic interpolation */
+                readonly quadratic: NullType;
+            }>;
+        }>;
+        /** KDE model (cloudpickle serialized) */
+        readonly scipy_kde: StructType<{
+            /** Serialized KDE model */
+            readonly data: BlobType;
+            /** KDE metadata */
+            readonly metadata: StructType<{
+                /** Actual bandwidth factor used */
+                readonly bandwidth: FloatType;
+                /** Minimum of training data */
+                readonly data_min: FloatType;
+                /** Maximum of training data */
+                readonly data_max: FloatType;
+            }>;
+        }>;
+    }>>;
+    /**
+     * Evaluate a fitted KDE model at given points.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { Scipy, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const evaluate = East.function(
+     *     [Scipy.Types.ModelBlobType, VectorType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, points) => {
+     *         return $.return(Scipy.kdeEvaluate(model, points));
+     *     }
+     * );
+     * ```
+     */
+    readonly kdeEvaluate: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** 1D interpolator (cloudpickle serialized) */
+        readonly scipy_interp_1d: StructType<{
+            /** Serialized interpolator */
+            readonly data: BlobType;
+            /** Interpolation method used */
+            readonly kind: VariantType<{
+                /** Linear interpolation (default) */
+                readonly linear: NullType;
+                /** Cubic interpolation */
+                readonly cubic: NullType;
+                /** Quadratic interpolation */
+                readonly quadratic: NullType;
+            }>;
+        }>;
+        /** KDE model (cloudpickle serialized) */
+        readonly scipy_kde: StructType<{
+            /** Serialized KDE model */
+            readonly data: BlobType;
+            /** KDE metadata */
+            readonly metadata: StructType<{
+                /** Actual bandwidth factor used */
+                readonly bandwidth: FloatType;
+                /** Minimum of training data */
+                readonly data_min: FloatType;
+                /** Maximum of training data */
+                readonly data_max: FloatType;
+            }>;
+        }>;
+    }>, VectorType<FloatType>], VectorType<FloatType>>;
+    /** Type definitions */
+    readonly Types: {
+        readonly ScalarObjectiveType: FunctionType<[VectorType<FloatType>], FloatType>;
+        readonly OptimizeMethodType: VariantType<{
+            /** BFGS algorithm */
+            readonly bfgs: NullType;
+            /** L-BFGS-B algorithm (default) */
+            readonly l_bfgs_b: NullType;
+            /** Nelder-Mead simplex */
+            readonly nelder_mead: NullType;
+            /** Powell's method */
+            readonly powell: NullType;
+            /** Conjugate gradient */
+            readonly cg: NullType;
+        }>;
+        readonly InterpolationKindType: VariantType<{
+            /** Linear interpolation (default) */
+            readonly linear: NullType;
+            /** Cubic interpolation */
+            readonly cubic: NullType;
+            /** Quadratic interpolation */
+            readonly quadratic: NullType;
+        }>;
+        readonly HistogramBinMethodType: VariantType<{
+            /** Maximum of Sturges and FD estimators */
+            readonly auto: NullType;
+            /** Freedman-Diaconis estimator */
+            readonly fd: NullType;
+            /** Sturges estimator */
+            readonly sturges: NullType;
+            /** Scott's normal reference rule */
+            readonly scott: NullType;
+            /** Rice estimator */
+            readonly rice: NullType;
+            /** Square root estimator */
+            readonly sqrt: NullType;
+            /** Doane's estimator */
+            readonly doane: NullType;
+        }>;
+        readonly KdeBandwidthMethodType: VariantType<{
+            /** Scott's rule of thumb (default) */
+            readonly scott: NullType;
+            /** Silverman's rule of thumb */
+            readonly silverman: NullType;
+        }>;
+        readonly OptimizeConfigType: StructType<{
+            /** Optimization method */
+            readonly method: OptionType<VariantType<{
+                /** BFGS algorithm */
+                readonly bfgs: NullType;
+                /** L-BFGS-B algorithm (default) */
+                readonly l_bfgs_b: NullType;
+                /** Nelder-Mead simplex */
+                readonly nelder_mead: NullType;
+                /** Powell's method */
+                readonly powell: NullType;
+                /** Conjugate gradient */
+                readonly cg: NullType;
+            }>>;
+            /** Maximum number of iterations */
+            readonly max_iter: OptionType<IntegerType>;
+            /** Tolerance for convergence */
+            readonly tol: OptionType<FloatType>;
+        }>;
+        readonly InterpolateConfigType: StructType<{
+            /** Interpolation method */
+            readonly kind: OptionType<VariantType<{
+                /** Linear interpolation (default) */
+                readonly linear: NullType;
+                /** Cubic interpolation */
+                readonly cubic: NullType;
+                /** Quadratic interpolation */
+                readonly quadratic: NullType;
+            }>>;
+        }>;
+        readonly HistogramConfigType: StructType<{
+            /** Number of bins (default 10) */
+            readonly bins: OptionType<IntegerType>;
+            /** Auto bin method (overrides bins if set) */
+            readonly bin_method: OptionType<VariantType<{
+                /** Maximum of Sturges and FD estimators */
+                readonly auto: NullType;
+                /** Freedman-Diaconis estimator */
+                readonly fd: NullType;
+                /** Sturges estimator */
+                readonly sturges: NullType;
+                /** Scott's normal reference rule */
+                readonly scott: NullType;
+                /** Rice estimator */
+                readonly rice: NullType;
+                /** Square root estimator */
+                readonly sqrt: NullType;
+                /** Doane's estimator */
+                readonly doane: NullType;
+            }>>;
+            /** Lower bound */
+            readonly range_min: OptionType<FloatType>;
+            /** Upper bound */
+            readonly range_max: OptionType<FloatType>;
+            /** Normalize to probability density */
+            readonly density: OptionType<BooleanType>;
+            /** Per-element weights */
+            readonly weights: OptionType<VectorType<FloatType>>;
+        }>;
+        readonly KdeConfigType: StructType<{
+            /** Bandwidth selection method (default scott) */
+            readonly bandwidth: OptionType<VariantType<{
+                /** Scott's rule of thumb (default) */
+                readonly scott: NullType;
+                /** Silverman's rule of thumb */
+                readonly silverman: NullType;
+            }>>;
+            /** Custom scalar bandwidth (overrides method if set) */
+            readonly bandwidth_scalar: OptionType<FloatType>;
+            /** Per-datapoint weights */
+            readonly weights: OptionType<VectorType<FloatType>>;
+        }>;
+        readonly ParamBoundsType: StructType<{
+            /** Lower bounds for each parameter */
+            readonly lower: VectorType<FloatType>;
+            /** Upper bounds for each parameter */
+            readonly upper: VectorType<FloatType>;
+        }>;
+        readonly CustomCurveFunctionType: FunctionType<[FloatType, VectorType<FloatType>, VectorType<FloatType>], FloatType>;
+        readonly CurveFunctionType: VariantType<{
+            /** y = a * exp(-b * x), 2 params: [a, b] */
+            readonly exponential_decay: NullType;
+            /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
+            readonly exponential_with_offset: NullType;
+            /** y = a * exp(b * x), 2 params: [a, b] */
+            readonly exponential_growth: NullType;
+            /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
+            readonly logistic: NullType;
+            /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
+            readonly gompertz: NullType;
+            /** y = a * x^b, 2 params: [a, b] */
+            readonly power_law: NullType;
+            /** y = a + b * x, 2 params: [a, b] */
+            readonly linear: NullType;
+            /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
+            readonly quadratic: NullType;
+            /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
+            readonly cubic: NullType;
+            /** Custom function provided by user */
+            readonly custom: StructType<{
+                /** The curve function: (x, params, fixed_params) -> y */
+                readonly fn: FunctionType<[FloatType, VectorType<FloatType>, VectorType<FloatType>], FloatType>;
+                /** Number of parameters to optimize */
+                readonly n_params: IntegerType;
+                /** Optional parameter bounds */
+                readonly param_bounds: OptionType<StructType<{
+                    /** Lower bounds for each parameter */
+                    readonly lower: VectorType<FloatType>;
+                    /** Upper bounds for each parameter */
+                    readonly upper: VectorType<FloatType>;
+                }>>;
+                /** Optional fixed parameters passed to fn but not optimized */
+                readonly fixed_params: OptionType<VectorType<FloatType>>;
+            }>;
+        }>;
+        readonly CurveFitConfigType: StructType<{
+            /** Maximum number of function evaluations */
+            readonly max_iter: OptionType<IntegerType>;
+            /** Initial guess for parameters */
+            readonly initial_guess: OptionType<VectorType<FloatType>>;
+        }>;
+        readonly QuadraticConfigType: StructType<{
+            /** Quadratic term (symmetric positive definite) */
+            readonly A: MatrixType<FloatType>;
+            /** Linear term */
+            readonly b: VectorType<FloatType>;
+            /** Constant term */
+            readonly c: FloatType;
+        }>;
+        readonly StatsDescribeResultType: StructType<{
+            /** Number of observations */
+            readonly count: IntegerType;
+            /** Mean value */
+            readonly mean: FloatType;
+            /** Variance */
+            readonly variance: FloatType;
+            /** Skewness */
+            readonly skewness: FloatType;
+            /** Kurtosis */
+            readonly kurtosis: FloatType;
+            /** Minimum value */
+            readonly min: FloatType;
+            /** Maximum value */
+            readonly max: FloatType;
+        }>;
+        readonly RobustStatsResultType: StructType<{
+            /** Median value */
+            readonly median: FloatType;
+            /** Interquartile range (Q3 - Q1) */
+            readonly iqr: FloatType;
+            /** Median absolute deviation */
+            readonly mad: FloatType;
+            /** 25th percentile */
+            readonly q1: FloatType;
+            /** 75th percentile */
+            readonly q3: FloatType;
+        }>;
+        readonly CorrelationResultType: StructType<{
+            /** Correlation coefficient */
+            readonly correlation: FloatType;
+            /** P-value for hypothesis test */
+            readonly pvalue: FloatType;
+        }>;
+        readonly CurveFitResultType: StructType<{
+            /** Fitted parameters */
+            readonly params: VectorType<FloatType>;
+            /** Whether fit converged */
+            readonly success: BooleanType;
+            /** Coefficient of determination (R²) */
+            readonly r_squared: FloatType;
+        }>;
+        readonly OptimizeResultType: StructType<{
+            /** Optimal parameters */
+            readonly x: VectorType<FloatType>;
+            /** Function value at optimum */
+            readonly fun: FloatType;
+            /** Whether optimization succeeded */
+            readonly success: BooleanType;
+            /** Number of iterations */
+            readonly nit: IntegerType;
+        }>;
+        readonly HistogramResultType: StructType<{
+            /** Bin values (float to support density mode) */
+            readonly counts: VectorType<FloatType>;
+            /** Bin edges (length = len(counts) + 1) */
+            readonly bin_edges: VectorType<FloatType>;
+        }>;
+        readonly KdeResultType: StructType<{
+            /** Actual bandwidth factor used */
+            readonly bandwidth: FloatType;
+            /** Minimum of training data */
+            readonly data_min: FloatType;
+            /** Maximum of training data */
+            readonly data_max: FloatType;
+        }>;
+        readonly ModelBlobType: VariantType<{
+            /** 1D interpolator (cloudpickle serialized) */
+            readonly scipy_interp_1d: StructType<{
+                /** Serialized interpolator */
+                readonly data: BlobType;
+                /** Interpolation method used */
+                readonly kind: VariantType<{
+                    /** Linear interpolation (default) */
+                    readonly linear: NullType;
+                    /** Cubic interpolation */
+                    readonly cubic: NullType;
+                    /** Quadratic interpolation */
+                    readonly quadratic: NullType;
+                }>;
+            }>;
+            /** KDE model (cloudpickle serialized) */
+            readonly scipy_kde: StructType<{
+                /** Serialized KDE model */
+                readonly data: BlobType;
+                /** KDE metadata */
+                readonly metadata: StructType<{
+                    /** Actual bandwidth factor used */
+                    readonly bandwidth: FloatType;
+                    /** Minimum of training data */
+                    readonly data_min: FloatType;
+                    /** Maximum of training data */
+                    readonly data_max: FloatType;
+                }>;
+            }>;
+        }>;
+        readonly DualAnnealBoundsType: StructType<{
+            /** Lower bounds for each variable */
+            readonly lower: VectorType<FloatType>;
+            /** Upper bounds for each variable */
+            readonly upper: VectorType<FloatType>;
+        }>;
+        readonly DualAnnealConfigType: StructType<{
+            /** Maximum function evaluations (default: 1000) */
+            readonly maxfun: OptionType<IntegerType>;
+            /** Maximum iterations (default: 1000) */
+            readonly maxiter: OptionType<IntegerType>;
+            /** Initial temperature (default: 5230) */
+            readonly initial_temp: OptionType<FloatType>;
+            /** Temperature restart threshold (default: 2e-5) */
+            readonly restart_temp_ratio: OptionType<FloatType>;
+            /** Visiting distribution parameter (default: 2.62) */
+            readonly visit: OptionType<FloatType>;
+            /** Acceptance distribution parameter (default: -5.0) */
+            readonly accept: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            readonly seed: OptionType<IntegerType>;
+            /** Disable local search for speed (default: false) */
+            readonly no_local_search: OptionType<BooleanType>;
+        }>;
+        readonly DualAnnealResultType: StructType<{
+            /** Best solution found */
+            readonly x: VectorType<FloatType>;
+            /** Best objective value */
+            readonly fun: FloatType;
+            /** Number of function evaluations */
+            readonly nfev: IntegerType;
+            /** Number of iterations */
+            readonly nit: IntegerType;
+            /** Whether optimization succeeded */
+            readonly success: BooleanType;
+            /** Status message */
+            readonly message: StringType;
+        }>;
+    };
+};
+//# sourceMappingURL=scipy.d.ts.map