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

package/dist/scipy/scipy.d.ts

@@ -1,1260 +0,0 @@
-/**
- * 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";
-export { VectorType, MatrixType, ScalarObjectiveType } from "../types.js";
-/**
- * Optimization method for scipy.optimize.minimize.
- */
-export declare const OptimizeMethodType: VariantType<{
-    /** BFGS algorithm */
-    bfgs: NullType;
-    /** L-BFGS-B algorithm (default) */
-    l_bfgs_b: NullType;
-    /** Nelder-Mead simplex */
-    nelder_mead: NullType;
-    /** Powell's method */
-    powell: NullType;
-    /** Conjugate gradient */
-    cg: NullType;
-}>;
-/**
- * Interpolation method for scipy.interpolate.interp1d.
- */
-export declare const InterpolationKindType: VariantType<{
-    /** Linear interpolation (default) */
-    linear: NullType;
-    /** Cubic interpolation */
-    cubic: NullType;
-    /** Quadratic interpolation */
-    quadratic: NullType;
-}>;
-/**
- * Configuration for scipy.optimize.minimize.
- */
-export declare const OptimizeConfigType: StructType<{
-    /** Optimization method */
-    method: OptionType<VariantType<{
-        /** BFGS algorithm */
-        bfgs: NullType;
-        /** L-BFGS-B algorithm (default) */
-        l_bfgs_b: NullType;
-        /** Nelder-Mead simplex */
-        nelder_mead: NullType;
-        /** Powell's method */
-        powell: NullType;
-        /** Conjugate gradient */
-        cg: NullType;
-    }>>;
-    /** Maximum number of iterations */
-    max_iter: OptionType<IntegerType>;
-    /** Tolerance for convergence */
-    tol: OptionType<FloatType>;
-}>;
-/**
- * Configuration for scipy.interpolate.interp1d.
- */
-export declare const InterpolateConfigType: StructType<{
-    /** Interpolation method */
-    kind: OptionType<VariantType<{
-        /** Linear interpolation (default) */
-        linear: NullType;
-        /** Cubic interpolation */
-        cubic: NullType;
-        /** Quadratic interpolation */
-        quadratic: NullType;
-    }>>;
-}>;
-/**
- * Parameter bounds for curve fitting.
- */
-export declare const ParamBoundsType: StructType<{
-    /** Lower bounds for each parameter */
-    lower: import("@elaraai/east").ArrayType<FloatType>;
-    /** Upper bounds for each parameter */
-    upper: import("@elaraai/east").ArrayType<FloatType>;
-}>;
-/**
- * Custom curve function type: (x: Float, params: Vector) -> Float
- */
-export declare const CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<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] */
-    exponential_decay: NullType;
-    /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-    exponential_with_offset: NullType;
-    /** y = a * exp(b * x), 2 params: [a, b] */
-    exponential_growth: NullType;
-    /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-    logistic: NullType;
-    /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-    gompertz: NullType;
-    /** y = a * x^b, 2 params: [a, b] */
-    power_law: NullType;
-    /** y = a + b * x, 2 params: [a, b] */
-    linear: NullType;
-    /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-    quadratic: NullType;
-    /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-    cubic: NullType;
-    /** Custom function provided by user */
-    custom: StructType<{
-        /** The curve function */
-        fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-        /** Number of parameters to optimize */
-        n_params: IntegerType;
-        /** Optional parameter bounds */
-        param_bounds: OptionType<StructType<{
-            /** Lower bounds for each parameter */
-            lower: import("@elaraai/east").ArrayType<FloatType>;
-            /** Upper bounds for each parameter */
-            upper: import("@elaraai/east").ArrayType<FloatType>;
-        }>>;
-    }>;
-}>;
-/**
- * Configuration for curve fitting.
- */
-export declare const CurveFitConfigType: StructType<{
-    /** Maximum number of function evaluations */
-    max_iter: OptionType<IntegerType>;
-    /** Initial guess for parameters */
-    initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
-}>;
-/**
- * Configuration for quadratic optimization: f(x) = 0.5 * x'Ax + b'x + c
- */
-export declare const QuadraticConfigType: StructType<{
-    /** Quadratic term (symmetric positive definite) */
-    A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
-    /** Linear term */
-    b: import("@elaraai/east").ArrayType<FloatType>;
-    /** Constant term */
-    c: FloatType;
-}>;
-/**
- * Descriptive statistics result.
- */
-export declare const StatsDescribeResultType: StructType<{
-    /** Number of observations */
-    count: IntegerType;
-    /** Mean value */
-    mean: FloatType;
-    /** Variance */
-    variance: FloatType;
-    /** Skewness */
-    skewness: FloatType;
-    /** Kurtosis */
-    kurtosis: FloatType;
-    /** Minimum value */
-    min: FloatType;
-    /** Maximum value */
-    max: FloatType;
-}>;
-/**
- * Robust statistics result (median-based, outlier-resistant).
- */
-export declare const RobustStatsResultType: StructType<{
-    /** Median value */
-    median: FloatType;
-    /** Interquartile range (Q3 - Q1) */
-    iqr: FloatType;
-    /** Median absolute deviation */
-    mad: FloatType;
-    /** 25th percentile */
-    q1: FloatType;
-    /** 75th percentile */
-    q3: FloatType;
-}>;
-/**
- * Correlation result (Pearson or Spearman).
- */
-export declare const CorrelationResultType: StructType<{
-    /** Correlation coefficient */
-    correlation: FloatType;
-    /** P-value for hypothesis test */
-    pvalue: FloatType;
-}>;
-/**
- * Curve fitting result.
- */
-export declare const CurveFitResultType: StructType<{
-    /** Fitted parameters */
-    params: import("@elaraai/east").ArrayType<FloatType>;
-    /** Whether fit converged */
-    success: BooleanType;
-    /** Coefficient of determination (R²) */
-    r_squared: FloatType;
-}>;
-/**
- * Optimization result.
- */
-export declare const OptimizeResultType: StructType<{
-    /** Optimal parameters */
-    x: import("@elaraai/east").ArrayType<FloatType>;
-    /** Function value at optimum */
-    fun: FloatType;
-    /** Whether optimization succeeded */
-    success: BooleanType;
-    /** Number of iterations */
-    nit: IntegerType;
-}>;
-/**
- * Model blob type for scipy interpolators.
- */
-export declare const ScipyModelBlobType: VariantType<{
-    /** 1D interpolator (cloudpickle serialized) */
-    scipy_interp_1d: StructType<{
-        /** Serialized interpolator */
-        data: BlobType;
-        /** Interpolation method used */
-        kind: VariantType<{
-            /** Linear interpolation (default) */
-            linear: NullType;
-            /** Cubic interpolation */
-            cubic: NullType;
-            /** Quadratic interpolation */
-            quadratic: NullType;
-        }>;
-    }>;
-}>;
-/**
- * Bounds for dual annealing optimization (required).
- */
-export declare const DualAnnealBoundsType: StructType<{
-    /** Lower bounds for each variable */
-    lower: import("@elaraai/east").ArrayType<FloatType>;
-    /** Upper bounds for each variable */
-    upper: import("@elaraai/east").ArrayType<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) */
-    maxfun: OptionType<IntegerType>;
-    /** Maximum iterations (default: 1000) */
-    maxiter: OptionType<IntegerType>;
-    /** Initial temperature (default: 5230) */
-    initial_temp: OptionType<FloatType>;
-    /** Temperature restart threshold (default: 2e-5) */
-    restart_temp_ratio: OptionType<FloatType>;
-    /** Visiting distribution parameter (default: 2.62) */
-    visit: OptionType<FloatType>;
-    /** Acceptance distribution parameter (default: -5.0) */
-    accept: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    seed: OptionType<IntegerType>;
-    /** Disable local search for speed (default: false) */
-    no_local_search: OptionType<BooleanType>;
-}>;
-/**
- * Result from dual annealing optimization.
- */
-export declare const DualAnnealResultType: StructType<{
-    /** Best solution found */
-    x: import("@elaraai/east").ArrayType<FloatType>;
-    /** Best objective value */
-    fun: FloatType;
-    /** Number of function evaluations */
-    nfev: IntegerType;
-    /** Number of iterations */
-    nit: IntegerType;
-    /** Whether optimization succeeded */
-    success: BooleanType;
-    /** Status message */
-    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] */
-    exponential_decay: NullType;
-    /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-    exponential_with_offset: NullType;
-    /** y = a * exp(b * x), 2 params: [a, b] */
-    exponential_growth: NullType;
-    /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-    logistic: NullType;
-    /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-    gompertz: NullType;
-    /** y = a * x^b, 2 params: [a, b] */
-    power_law: NullType;
-    /** y = a + b * x, 2 params: [a, b] */
-    linear: NullType;
-    /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-    quadratic: NullType;
-    /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-    cubic: NullType;
-    /** Custom function provided by user */
-    custom: StructType<{
-        /** The curve function */
-        fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-        /** Number of parameters to optimize */
-        n_params: IntegerType;
-        /** Optional parameter bounds */
-        param_bounds: OptionType<StructType<{
-            /** Lower bounds for each parameter */
-            lower: import("@elaraai/east").ArrayType<FloatType>;
-            /** Upper bounds for each parameter */
-            upper: import("@elaraai/east").ArrayType<FloatType>;
-        }>>;
-    }>;
-}>, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
-    /** Maximum number of function evaluations */
-    max_iter: OptionType<IntegerType>;
-    /** Initial guess for parameters */
-    initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
-}>], StructType<{
-    /** Fitted parameters */
-    params: import("@elaraai/east").ArrayType<FloatType>;
-    /** Whether fit converged */
-    success: BooleanType;
-    /** Coefficient of determination (R²) */
-    r_squared: FloatType;
-}>>;
-/**
- * Compute descriptive statistics for data.
- */
-export declare const scipy_stats_describe: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], StructType<{
-    /** Number of observations */
-    count: IntegerType;
-    /** Mean value */
-    mean: FloatType;
-    /** Variance */
-    variance: FloatType;
-    /** Skewness */
-    skewness: FloatType;
-    /** Kurtosis */
-    kurtosis: FloatType;
-    /** Minimum value */
-    min: FloatType;
-    /** Maximum value */
-    max: FloatType;
-}>>;
-/**
- * Compute Pearson correlation coefficient.
- */
-export declare const scipy_stats_pearsonr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], StructType<{
-    /** Correlation coefficient */
-    correlation: FloatType;
-    /** P-value for hypothesis test */
-    pvalue: FloatType;
-}>>;
-/**
- * Compute Spearman rank correlation.
- */
-export declare const scipy_stats_spearmanr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], StructType<{
-    /** Correlation coefficient */
-    correlation: FloatType;
-    /** P-value for hypothesis test */
-    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<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], import("@elaraai/east").ArrayType<FloatType>>;
-/**
- * Compute interquartile range (Q3 - Q1).
- */
-export declare const scipy_stats_iqr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-/**
- * Compute median value.
- */
-export declare const scipy_stats_median: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-/**
- * Compute median absolute deviation (robust std estimate).
- */
-export declare const scipy_stats_mad: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-/**
- * Compute robust statistics in one call (median, iqr, mad, q1, q3).
- */
-export declare const scipy_stats_robust: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], StructType<{
-    /** Median value */
-    median: FloatType;
-    /** Interquartile range (Q3 - Q1) */
-    iqr: FloatType;
-    /** Median absolute deviation */
-    mad: FloatType;
-    /** 25th percentile */
-    q1: FloatType;
-    /** 75th percentile */
-    q3: FloatType;
-}>>;
-/**
- * Fit 1D interpolator to data.
- */
-export declare const scipy_interpolate_1d_fit: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
-    /** Interpolation method */
-    kind: OptionType<VariantType<{
-        /** Linear interpolation (default) */
-        linear: NullType;
-        /** Cubic interpolation */
-        cubic: NullType;
-        /** Quadratic interpolation */
-        quadratic: NullType;
-    }>>;
-}>], VariantType<{
-    /** 1D interpolator (cloudpickle serialized) */
-    scipy_interp_1d: StructType<{
-        /** Serialized interpolator */
-        data: BlobType;
-        /** Interpolation method used */
-        kind: VariantType<{
-            /** Linear interpolation (default) */
-            linear: NullType;
-            /** Cubic interpolation */
-            cubic: NullType;
-            /** Quadratic interpolation */
-            quadratic: NullType;
-        }>;
-    }>;
-}>>;
-/**
- * Evaluate 1D interpolator at given points.
- */
-export declare const scipy_interpolate_1d_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
-    /** 1D interpolator (cloudpickle serialized) */
-    scipy_interp_1d: StructType<{
-        /** Serialized interpolator */
-        data: BlobType;
-        /** Interpolation method used */
-        kind: VariantType<{
-            /** Linear interpolation (default) */
-            linear: NullType;
-            /** Cubic interpolation */
-            cubic: NullType;
-            /** Quadratic interpolation */
-            quadratic: NullType;
-        }>;
-    }>;
-}>, import("@elaraai/east").ArrayType<FloatType>], import("@elaraai/east").ArrayType<FloatType>>;
-/**
- * Minimize a scalar function using scipy.optimize.minimize.
- */
-export declare const scipy_optimize_minimize: import("@elaraai/east").PlatformDefinition<[FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
-    /** Optimization method */
-    method: OptionType<VariantType<{
-        /** BFGS algorithm */
-        bfgs: NullType;
-        /** L-BFGS-B algorithm (default) */
-        l_bfgs_b: NullType;
-        /** Nelder-Mead simplex */
-        nelder_mead: NullType;
-        /** Powell's method */
-        powell: NullType;
-        /** Conjugate gradient */
-        cg: NullType;
-    }>>;
-    /** Maximum number of iterations */
-    max_iter: OptionType<IntegerType>;
-    /** Tolerance for convergence */
-    tol: OptionType<FloatType>;
-}>], StructType<{
-    /** Optimal parameters */
-    x: import("@elaraai/east").ArrayType<FloatType>;
-    /** Function value at optimum */
-    fun: FloatType;
-    /** Whether optimization succeeded */
-    success: BooleanType;
-    /** Number of iterations */
-    nit: IntegerType;
-}>>;
-/**
- * Minimize a quadratic function with analytical gradient.
- */
-export declare const scipy_optimize_minimize_quadratic: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, StructType<{
-    /** Quadratic term (symmetric positive definite) */
-    A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
-    /** Linear term */
-    b: import("@elaraai/east").ArrayType<FloatType>;
-    /** Constant term */
-    c: FloatType;
-}>, StructType<{
-    /** Optimization method */
-    method: OptionType<VariantType<{
-        /** BFGS algorithm */
-        bfgs: NullType;
-        /** L-BFGS-B algorithm (default) */
-        l_bfgs_b: NullType;
-        /** Nelder-Mead simplex */
-        nelder_mead: NullType;
-        /** Powell's method */
-        powell: NullType;
-        /** Conjugate gradient */
-        cg: NullType;
-    }>>;
-    /** Maximum number of iterations */
-    max_iter: OptionType<IntegerType>;
-    /** Tolerance for convergence */
-    tol: OptionType<FloatType>;
-}>], StructType<{
-    /** Optimal parameters */
-    x: import("@elaraai/east").ArrayType<FloatType>;
-    /** Function value at optimum */
-    fun: FloatType;
-    /** Whether optimization succeeded */
-    success: BooleanType;
-    /** Number of iterations */
-    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<[import("@elaraai/east").ArrayType<FloatType>], FloatType>, OptionType<import("@elaraai/east").ArrayType<FloatType>>, StructType<{
-    /** Lower bounds for each variable */
-    lower: import("@elaraai/east").ArrayType<FloatType>;
-    /** Upper bounds for each variable */
-    upper: import("@elaraai/east").ArrayType<FloatType>;
-}>, StructType<{
-    /** Maximum function evaluations (default: 1000) */
-    maxfun: OptionType<IntegerType>;
-    /** Maximum iterations (default: 1000) */
-    maxiter: OptionType<IntegerType>;
-    /** Initial temperature (default: 5230) */
-    initial_temp: OptionType<FloatType>;
-    /** Temperature restart threshold (default: 2e-5) */
-    restart_temp_ratio: OptionType<FloatType>;
-    /** Visiting distribution parameter (default: 2.62) */
-    visit: OptionType<FloatType>;
-    /** Acceptance distribution parameter (default: -5.0) */
-    accept: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    seed: OptionType<IntegerType>;
-    /** Disable local search for speed (default: false) */
-    no_local_search: OptionType<BooleanType>;
-}>], StructType<{
-    /** Best solution found */
-    x: import("@elaraai/east").ArrayType<FloatType>;
-    /** Best objective value */
-    fun: FloatType;
-    /** Number of function evaluations */
-    nfev: IntegerType;
-    /** Number of iterations */
-    nit: IntegerType;
-    /** Whether optimization succeeded */
-    success: BooleanType;
-    /** Status message */
-    message: StringType;
-}>>;
-/**
- * Type definitions for scipy functions.
- */
-export declare const ScipyTypes: {
-    readonly VectorType: import("@elaraai/east").ArrayType<FloatType>;
-    readonly MatrixType: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
-    readonly ScalarObjectiveType: FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-    readonly OptimizeMethodType: VariantType<{
-        /** BFGS algorithm */
-        bfgs: NullType;
-        /** L-BFGS-B algorithm (default) */
-        l_bfgs_b: NullType;
-        /** Nelder-Mead simplex */
-        nelder_mead: NullType;
-        /** Powell's method */
-        powell: NullType;
-        /** Conjugate gradient */
-        cg: NullType;
-    }>;
-    readonly InterpolationKindType: VariantType<{
-        /** Linear interpolation (default) */
-        linear: NullType;
-        /** Cubic interpolation */
-        cubic: NullType;
-        /** Quadratic interpolation */
-        quadratic: NullType;
-    }>;
-    readonly OptimizeConfigType: StructType<{
-        /** Optimization method */
-        method: OptionType<VariantType<{
-            /** BFGS algorithm */
-            bfgs: NullType;
-            /** L-BFGS-B algorithm (default) */
-            l_bfgs_b: NullType;
-            /** Nelder-Mead simplex */
-            nelder_mead: NullType;
-            /** Powell's method */
-            powell: NullType;
-            /** Conjugate gradient */
-            cg: NullType;
-        }>>;
-        /** Maximum number of iterations */
-        max_iter: OptionType<IntegerType>;
-        /** Tolerance for convergence */
-        tol: OptionType<FloatType>;
-    }>;
-    readonly InterpolateConfigType: StructType<{
-        /** Interpolation method */
-        kind: OptionType<VariantType<{
-            /** Linear interpolation (default) */
-            linear: NullType;
-            /** Cubic interpolation */
-            cubic: NullType;
-            /** Quadratic interpolation */
-            quadratic: NullType;
-        }>>;
-    }>;
-    readonly ParamBoundsType: StructType<{
-        /** Lower bounds for each parameter */
-        lower: import("@elaraai/east").ArrayType<FloatType>;
-        /** Upper bounds for each parameter */
-        upper: import("@elaraai/east").ArrayType<FloatType>;
-    }>;
-    readonly CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-    readonly CurveFunctionType: VariantType<{
-        /** y = a * exp(-b * x), 2 params: [a, b] */
-        exponential_decay: NullType;
-        /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-        exponential_with_offset: NullType;
-        /** y = a * exp(b * x), 2 params: [a, b] */
-        exponential_growth: NullType;
-        /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-        logistic: NullType;
-        /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-        gompertz: NullType;
-        /** y = a * x^b, 2 params: [a, b] */
-        power_law: NullType;
-        /** y = a + b * x, 2 params: [a, b] */
-        linear: NullType;
-        /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-        quadratic: NullType;
-        /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-        cubic: NullType;
-        /** Custom function provided by user */
-        custom: StructType<{
-            /** The curve function */
-            fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-            /** Number of parameters to optimize */
-            n_params: IntegerType;
-            /** Optional parameter bounds */
-            param_bounds: OptionType<StructType<{
-                /** Lower bounds for each parameter */
-                lower: import("@elaraai/east").ArrayType<FloatType>;
-                /** Upper bounds for each parameter */
-                upper: import("@elaraai/east").ArrayType<FloatType>;
-            }>>;
-        }>;
-    }>;
-    readonly CurveFitConfigType: StructType<{
-        /** Maximum number of function evaluations */
-        max_iter: OptionType<IntegerType>;
-        /** Initial guess for parameters */
-        initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
-    }>;
-    readonly QuadraticConfigType: StructType<{
-        /** Quadratic term (symmetric positive definite) */
-        A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
-        /** Linear term */
-        b: import("@elaraai/east").ArrayType<FloatType>;
-        /** Constant term */
-        c: FloatType;
-    }>;
-    readonly StatsDescribeResultType: StructType<{
-        /** Number of observations */
-        count: IntegerType;
-        /** Mean value */
-        mean: FloatType;
-        /** Variance */
-        variance: FloatType;
-        /** Skewness */
-        skewness: FloatType;
-        /** Kurtosis */
-        kurtosis: FloatType;
-        /** Minimum value */
-        min: FloatType;
-        /** Maximum value */
-        max: FloatType;
-    }>;
-    readonly RobustStatsResultType: StructType<{
-        /** Median value */
-        median: FloatType;
-        /** Interquartile range (Q3 - Q1) */
-        iqr: FloatType;
-        /** Median absolute deviation */
-        mad: FloatType;
-        /** 25th percentile */
-        q1: FloatType;
-        /** 75th percentile */
-        q3: FloatType;
-    }>;
-    readonly CorrelationResultType: StructType<{
-        /** Correlation coefficient */
-        correlation: FloatType;
-        /** P-value for hypothesis test */
-        pvalue: FloatType;
-    }>;
-    readonly CurveFitResultType: StructType<{
-        /** Fitted parameters */
-        params: import("@elaraai/east").ArrayType<FloatType>;
-        /** Whether fit converged */
-        success: BooleanType;
-        /** Coefficient of determination (R²) */
-        r_squared: FloatType;
-    }>;
-    readonly OptimizeResultType: StructType<{
-        /** Optimal parameters */
-        x: import("@elaraai/east").ArrayType<FloatType>;
-        /** Function value at optimum */
-        fun: FloatType;
-        /** Whether optimization succeeded */
-        success: BooleanType;
-        /** Number of iterations */
-        nit: IntegerType;
-    }>;
-    readonly ModelBlobType: VariantType<{
-        /** 1D interpolator (cloudpickle serialized) */
-        scipy_interp_1d: StructType<{
-            /** Serialized interpolator */
-            data: BlobType;
-            /** Interpolation method used */
-            kind: VariantType<{
-                /** Linear interpolation (default) */
-                linear: NullType;
-                /** Cubic interpolation */
-                cubic: NullType;
-                /** Quadratic interpolation */
-                quadratic: NullType;
-            }>;
-        }>;
-    }>;
-    readonly DualAnnealBoundsType: StructType<{
-        /** Lower bounds for each variable */
-        lower: import("@elaraai/east").ArrayType<FloatType>;
-        /** Upper bounds for each variable */
-        upper: import("@elaraai/east").ArrayType<FloatType>;
-    }>;
-    readonly DualAnnealConfigType: StructType<{
-        /** Maximum function evaluations (default: 1000) */
-        maxfun: OptionType<IntegerType>;
-        /** Maximum iterations (default: 1000) */
-        maxiter: OptionType<IntegerType>;
-        /** Initial temperature (default: 5230) */
-        initial_temp: OptionType<FloatType>;
-        /** Temperature restart threshold (default: 2e-5) */
-        restart_temp_ratio: OptionType<FloatType>;
-        /** Visiting distribution parameter (default: 2.62) */
-        visit: OptionType<FloatType>;
-        /** Acceptance distribution parameter (default: -5.0) */
-        accept: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        seed: OptionType<IntegerType>;
-        /** Disable local search for speed (default: false) */
-        no_local_search: OptionType<BooleanType>;
-    }>;
-    readonly DualAnnealResultType: StructType<{
-        /** Best solution found */
-        x: import("@elaraai/east").ArrayType<FloatType>;
-        /** Best objective value */
-        fun: FloatType;
-        /** Number of function evaluations */
-        nfev: IntegerType;
-        /** Number of iterations */
-        nit: IntegerType;
-        /** Whether optimization succeeded */
-        success: BooleanType;
-        /** Status message */
-        message: StringType;
-    }>;
-};
-/**
- * SciPy scientific computing utilities.
- *
- * Provides statistics, optimization, interpolation, and curve fitting.
- */
-export declare const Scipy: {
-    /** Fit parametric curve to data */
-    readonly curveFit: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        /** y = a * exp(-b * x), 2 params: [a, b] */
-        exponential_decay: NullType;
-        /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-        exponential_with_offset: NullType;
-        /** y = a * exp(b * x), 2 params: [a, b] */
-        exponential_growth: NullType;
-        /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-        logistic: NullType;
-        /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-        gompertz: NullType;
-        /** y = a * x^b, 2 params: [a, b] */
-        power_law: NullType;
-        /** y = a + b * x, 2 params: [a, b] */
-        linear: NullType;
-        /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-        quadratic: NullType;
-        /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-        cubic: NullType;
-        /** Custom function provided by user */
-        custom: StructType<{
-            /** The curve function */
-            fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-            /** Number of parameters to optimize */
-            n_params: IntegerType;
-            /** Optional parameter bounds */
-            param_bounds: OptionType<StructType<{
-                /** Lower bounds for each parameter */
-                lower: import("@elaraai/east").ArrayType<FloatType>;
-                /** Upper bounds for each parameter */
-                upper: import("@elaraai/east").ArrayType<FloatType>;
-            }>>;
-        }>;
-    }>, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
-        /** Maximum number of function evaluations */
-        max_iter: OptionType<IntegerType>;
-        /** Initial guess for parameters */
-        initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
-    }>], StructType<{
-        /** Fitted parameters */
-        params: import("@elaraai/east").ArrayType<FloatType>;
-        /** Whether fit converged */
-        success: BooleanType;
-        /** Coefficient of determination (R²) */
-        r_squared: FloatType;
-    }>>;
-    /** Compute descriptive statistics */
-    readonly statsDescribe: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], StructType<{
-        /** Number of observations */
-        count: IntegerType;
-        /** Mean value */
-        mean: FloatType;
-        /** Variance */
-        variance: FloatType;
-        /** Skewness */
-        skewness: FloatType;
-        /** Kurtosis */
-        kurtosis: FloatType;
-        /** Minimum value */
-        min: FloatType;
-        /** Maximum value */
-        max: FloatType;
-    }>>;
-    /** Compute Pearson correlation */
-    readonly statsPearsonr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], StructType<{
-        /** Correlation coefficient */
-        correlation: FloatType;
-        /** P-value for hypothesis test */
-        pvalue: FloatType;
-    }>>;
-    /** Compute Spearman correlation */
-    readonly statsSpearmanr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], StructType<{
-        /** Correlation coefficient */
-        correlation: FloatType;
-        /** P-value for hypothesis test */
-        pvalue: FloatType;
-    }>>;
-    /** Compute percentiles */
-    readonly statsPercentile: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], import("@elaraai/east").ArrayType<FloatType>>;
-    /** Compute interquartile range */
-    readonly statsIqr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-    /** Compute median */
-    readonly statsMedian: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-    /** Compute median absolute deviation */
-    readonly statsMad: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-    /** Compute robust statistics (median, iqr, mad, q1, q3) */
-    readonly statsRobust: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], StructType<{
-        /** Median value */
-        median: FloatType;
-        /** Interquartile range (Q3 - Q1) */
-        iqr: FloatType;
-        /** Median absolute deviation */
-        mad: FloatType;
-        /** 25th percentile */
-        q1: FloatType;
-        /** 75th percentile */
-        q3: FloatType;
-    }>>;
-    /** Fit 1D interpolator */
-    readonly interpolate1dFit: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
-        /** Interpolation method */
-        kind: OptionType<VariantType<{
-            /** Linear interpolation (default) */
-            linear: NullType;
-            /** Cubic interpolation */
-            cubic: NullType;
-            /** Quadratic interpolation */
-            quadratic: NullType;
-        }>>;
-    }>], VariantType<{
-        /** 1D interpolator (cloudpickle serialized) */
-        scipy_interp_1d: StructType<{
-            /** Serialized interpolator */
-            data: BlobType;
-            /** Interpolation method used */
-            kind: VariantType<{
-                /** Linear interpolation (default) */
-                linear: NullType;
-                /** Cubic interpolation */
-                cubic: NullType;
-                /** Quadratic interpolation */
-                quadratic: NullType;
-            }>;
-        }>;
-    }>>;
-    /** Evaluate 1D interpolator */
-    readonly interpolate1dPredict: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        /** 1D interpolator (cloudpickle serialized) */
-        scipy_interp_1d: StructType<{
-            /** Serialized interpolator */
-            data: BlobType;
-            /** Interpolation method used */
-            kind: VariantType<{
-                /** Linear interpolation (default) */
-                linear: NullType;
-                /** Cubic interpolation */
-                cubic: NullType;
-                /** Quadratic interpolation */
-                quadratic: NullType;
-            }>;
-        }>;
-    }>, import("@elaraai/east").ArrayType<FloatType>], import("@elaraai/east").ArrayType<FloatType>>;
-    /** Minimize scalar function */
-    readonly optimizeMinimize: import("@elaraai/east").PlatformDefinition<[FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
-        /** Optimization method */
-        method: OptionType<VariantType<{
-            /** BFGS algorithm */
-            bfgs: NullType;
-            /** L-BFGS-B algorithm (default) */
-            l_bfgs_b: NullType;
-            /** Nelder-Mead simplex */
-            nelder_mead: NullType;
-            /** Powell's method */
-            powell: NullType;
-            /** Conjugate gradient */
-            cg: NullType;
-        }>>;
-        /** Maximum number of iterations */
-        max_iter: OptionType<IntegerType>;
-        /** Tolerance for convergence */
-        tol: OptionType<FloatType>;
-    }>], StructType<{
-        /** Optimal parameters */
-        x: import("@elaraai/east").ArrayType<FloatType>;
-        /** Function value at optimum */
-        fun: FloatType;
-        /** Whether optimization succeeded */
-        success: BooleanType;
-        /** Number of iterations */
-        nit: IntegerType;
-    }>>;
-    /** Minimize quadratic function */
-    readonly optimizeMinimizeQuadratic: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, StructType<{
-        /** Quadratic term (symmetric positive definite) */
-        A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
-        /** Linear term */
-        b: import("@elaraai/east").ArrayType<FloatType>;
-        /** Constant term */
-        c: FloatType;
-    }>, StructType<{
-        /** Optimization method */
-        method: OptionType<VariantType<{
-            /** BFGS algorithm */
-            bfgs: NullType;
-            /** L-BFGS-B algorithm (default) */
-            l_bfgs_b: NullType;
-            /** Nelder-Mead simplex */
-            nelder_mead: NullType;
-            /** Powell's method */
-            powell: NullType;
-            /** Conjugate gradient */
-            cg: NullType;
-        }>>;
-        /** Maximum number of iterations */
-        max_iter: OptionType<IntegerType>;
-        /** Tolerance for convergence */
-        tol: OptionType<FloatType>;
-    }>], StructType<{
-        /** Optimal parameters */
-        x: import("@elaraai/east").ArrayType<FloatType>;
-        /** Function value at optimum */
-        fun: FloatType;
-        /** Whether optimization succeeded */
-        success: BooleanType;
-        /** Number of iterations */
-        nit: IntegerType;
-    }>>;
-    /** Global optimization using dual annealing */
-    readonly optimizeDualAnnealing: import("@elaraai/east").PlatformDefinition<[FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>, OptionType<import("@elaraai/east").ArrayType<FloatType>>, StructType<{
-        /** Lower bounds for each variable */
-        lower: import("@elaraai/east").ArrayType<FloatType>;
-        /** Upper bounds for each variable */
-        upper: import("@elaraai/east").ArrayType<FloatType>;
-    }>, StructType<{
-        /** Maximum function evaluations (default: 1000) */
-        maxfun: OptionType<IntegerType>;
-        /** Maximum iterations (default: 1000) */
-        maxiter: OptionType<IntegerType>;
-        /** Initial temperature (default: 5230) */
-        initial_temp: OptionType<FloatType>;
-        /** Temperature restart threshold (default: 2e-5) */
-        restart_temp_ratio: OptionType<FloatType>;
-        /** Visiting distribution parameter (default: 2.62) */
-        visit: OptionType<FloatType>;
-        /** Acceptance distribution parameter (default: -5.0) */
-        accept: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        seed: OptionType<IntegerType>;
-        /** Disable local search for speed (default: false) */
-        no_local_search: OptionType<BooleanType>;
-    }>], StructType<{
-        /** Best solution found */
-        x: import("@elaraai/east").ArrayType<FloatType>;
-        /** Best objective value */
-        fun: FloatType;
-        /** Number of function evaluations */
-        nfev: IntegerType;
-        /** Number of iterations */
-        nit: IntegerType;
-        /** Whether optimization succeeded */
-        success: BooleanType;
-        /** Status message */
-        message: StringType;
-    }>>;
-    /** Type definitions */
-    readonly Types: {
-        readonly VectorType: import("@elaraai/east").ArrayType<FloatType>;
-        readonly MatrixType: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
-        readonly ScalarObjectiveType: FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-        readonly OptimizeMethodType: VariantType<{
-            /** BFGS algorithm */
-            bfgs: NullType;
-            /** L-BFGS-B algorithm (default) */
-            l_bfgs_b: NullType;
-            /** Nelder-Mead simplex */
-            nelder_mead: NullType;
-            /** Powell's method */
-            powell: NullType;
-            /** Conjugate gradient */
-            cg: NullType;
-        }>;
-        readonly InterpolationKindType: VariantType<{
-            /** Linear interpolation (default) */
-            linear: NullType;
-            /** Cubic interpolation */
-            cubic: NullType;
-            /** Quadratic interpolation */
-            quadratic: NullType;
-        }>;
-        readonly OptimizeConfigType: StructType<{
-            /** Optimization method */
-            method: OptionType<VariantType<{
-                /** BFGS algorithm */
-                bfgs: NullType;
-                /** L-BFGS-B algorithm (default) */
-                l_bfgs_b: NullType;
-                /** Nelder-Mead simplex */
-                nelder_mead: NullType;
-                /** Powell's method */
-                powell: NullType;
-                /** Conjugate gradient */
-                cg: NullType;
-            }>>;
-            /** Maximum number of iterations */
-            max_iter: OptionType<IntegerType>;
-            /** Tolerance for convergence */
-            tol: OptionType<FloatType>;
-        }>;
-        readonly InterpolateConfigType: StructType<{
-            /** Interpolation method */
-            kind: OptionType<VariantType<{
-                /** Linear interpolation (default) */
-                linear: NullType;
-                /** Cubic interpolation */
-                cubic: NullType;
-                /** Quadratic interpolation */
-                quadratic: NullType;
-            }>>;
-        }>;
-        readonly ParamBoundsType: StructType<{
-            /** Lower bounds for each parameter */
-            lower: import("@elaraai/east").ArrayType<FloatType>;
-            /** Upper bounds for each parameter */
-            upper: import("@elaraai/east").ArrayType<FloatType>;
-        }>;
-        readonly CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-        readonly CurveFunctionType: VariantType<{
-            /** y = a * exp(-b * x), 2 params: [a, b] */
-            exponential_decay: NullType;
-            /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-            exponential_with_offset: NullType;
-            /** y = a * exp(b * x), 2 params: [a, b] */
-            exponential_growth: NullType;
-            /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-            logistic: NullType;
-            /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-            gompertz: NullType;
-            /** y = a * x^b, 2 params: [a, b] */
-            power_law: NullType;
-            /** y = a + b * x, 2 params: [a, b] */
-            linear: NullType;
-            /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-            quadratic: NullType;
-            /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-            cubic: NullType;
-            /** Custom function provided by user */
-            custom: StructType<{
-                /** The curve function */
-                fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
-                /** Number of parameters to optimize */
-                n_params: IntegerType;
-                /** Optional parameter bounds */
-                param_bounds: OptionType<StructType<{
-                    /** Lower bounds for each parameter */
-                    lower: import("@elaraai/east").ArrayType<FloatType>;
-                    /** Upper bounds for each parameter */
-                    upper: import("@elaraai/east").ArrayType<FloatType>;
-                }>>;
-            }>;
-        }>;
-        readonly CurveFitConfigType: StructType<{
-            /** Maximum number of function evaluations */
-            max_iter: OptionType<IntegerType>;
-            /** Initial guess for parameters */
-            initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
-        }>;
-        readonly QuadraticConfigType: StructType<{
-            /** Quadratic term (symmetric positive definite) */
-            A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
-            /** Linear term */
-            b: import("@elaraai/east").ArrayType<FloatType>;
-            /** Constant term */
-            c: FloatType;
-        }>;
-        readonly StatsDescribeResultType: StructType<{
-            /** Number of observations */
-            count: IntegerType;
-            /** Mean value */
-            mean: FloatType;
-            /** Variance */
-            variance: FloatType;
-            /** Skewness */
-            skewness: FloatType;
-            /** Kurtosis */
-            kurtosis: FloatType;
-            /** Minimum value */
-            min: FloatType;
-            /** Maximum value */
-            max: FloatType;
-        }>;
-        readonly RobustStatsResultType: StructType<{
-            /** Median value */
-            median: FloatType;
-            /** Interquartile range (Q3 - Q1) */
-            iqr: FloatType;
-            /** Median absolute deviation */
-            mad: FloatType;
-            /** 25th percentile */
-            q1: FloatType;
-            /** 75th percentile */
-            q3: FloatType;
-        }>;
-        readonly CorrelationResultType: StructType<{
-            /** Correlation coefficient */
-            correlation: FloatType;
-            /** P-value for hypothesis test */
-            pvalue: FloatType;
-        }>;
-        readonly CurveFitResultType: StructType<{
-            /** Fitted parameters */
-            params: import("@elaraai/east").ArrayType<FloatType>;
-            /** Whether fit converged */
-            success: BooleanType;
-            /** Coefficient of determination (R²) */
-            r_squared: FloatType;
-        }>;
-        readonly OptimizeResultType: StructType<{
-            /** Optimal parameters */
-            x: import("@elaraai/east").ArrayType<FloatType>;
-            /** Function value at optimum */
-            fun: FloatType;
-            /** Whether optimization succeeded */
-            success: BooleanType;
-            /** Number of iterations */
-            nit: IntegerType;
-        }>;
-        readonly ModelBlobType: VariantType<{
-            /** 1D interpolator (cloudpickle serialized) */
-            scipy_interp_1d: StructType<{
-                /** Serialized interpolator */
-                data: BlobType;
-                /** Interpolation method used */
-                kind: VariantType<{
-                    /** Linear interpolation (default) */
-                    linear: NullType;
-                    /** Cubic interpolation */
-                    cubic: NullType;
-                    /** Quadratic interpolation */
-                    quadratic: NullType;
-                }>;
-            }>;
-        }>;
-        readonly DualAnnealBoundsType: StructType<{
-            /** Lower bounds for each variable */
-            lower: import("@elaraai/east").ArrayType<FloatType>;
-            /** Upper bounds for each variable */
-            upper: import("@elaraai/east").ArrayType<FloatType>;
-        }>;
-        readonly DualAnnealConfigType: StructType<{
-            /** Maximum function evaluations (default: 1000) */
-            maxfun: OptionType<IntegerType>;
-            /** Maximum iterations (default: 1000) */
-            maxiter: OptionType<IntegerType>;
-            /** Initial temperature (default: 5230) */
-            initial_temp: OptionType<FloatType>;
-            /** Temperature restart threshold (default: 2e-5) */
-            restart_temp_ratio: OptionType<FloatType>;
-            /** Visiting distribution parameter (default: 2.62) */
-            visit: OptionType<FloatType>;
-            /** Acceptance distribution parameter (default: -5.0) */
-            accept: OptionType<FloatType>;
-            /** Random seed for reproducibility */
-            seed: OptionType<IntegerType>;
-            /** Disable local search for speed (default: false) */
-            no_local_search: OptionType<BooleanType>;
-        }>;
-        readonly DualAnnealResultType: StructType<{
-            /** Best solution found */
-            x: import("@elaraai/east").ArrayType<FloatType>;
-            /** Best objective value */
-            fun: FloatType;
-            /** Number of function evaluations */
-            nfev: IntegerType;
-            /** Number of iterations */
-            nit: IntegerType;
-            /** Whether optimization succeeded */
-            success: BooleanType;
-            /** Status message */
-            message: StringType;
-        }>;
-    };
-};
-//# sourceMappingURL=scipy.d.ts.map