@elaraai/east-py-datascience 0.0.2-beta.1

package/dist/scipy/scipy.d.ts

@@ -0,0 +1,954 @@
+/**
+ * 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, 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;
+}>;
+/**
+ * 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;
+        }>;
+    }>;
+}>;
+/**
+ * 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;
+}>>;
+/**
+ * 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;
+}>>;
+/**
+ * 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 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;
+            }>;
+        }>;
+    }>;
+};
+/**
+ * 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;
+    }>>;
+    /** 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;
+    }>>;
+    /** 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 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;
+                }>;
+            }>;
+        }>;
+    };
+};
+//# sourceMappingURL=scipy.d.ts.map