@elaraai/east-py-datascience 1.0.1 → 1.0.2

package/dist/src/optuna/optuna.d.ts

@@ -0,0 +1,857 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Bayesian optimization using Optuna's TPE sampler.
+ *
+ * Provides parameter optimization for blackbox functions with mixed parameter
+ * types (categorical, integer, continuous). Useful for:
+ * - Hyperparameter tuning for ML models
+ * - Design optimization
+ * - Any blackbox optimization with structured parameter spaces
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, IntegerType, FloatType, StringType, BooleanType, FunctionType, NullType } from "@elaraai/east";
+/**
+ * Parameter value type (can be int, float, string, or bool).
+ */
+export declare const ParamValueType: VariantType<{
+    readonly int: IntegerType;
+    readonly float: FloatType;
+    readonly string: StringType;
+    readonly bool: BooleanType;
+}>;
+/**
+ * Parameter space kind for defining search spaces.
+ */
+export declare const ParamSpaceKindType: VariantType<{
+    /** Integer parameter with low/high bounds */
+    readonly int: NullType;
+    /** Float parameter with low/high bounds */
+    readonly float: NullType;
+    /** Categorical parameter with choices */
+    readonly categorical: NullType;
+    /** Log-uniform float parameter (for learning rates, etc.) */
+    readonly log_uniform: NullType;
+}>;
+/**
+ * Parameter search space definition.
+ *
+ * Defines a single parameter's name, type, and valid range/choices.
+ */
+export declare const ParamSpaceType: StructType<{
+    /** Parameter name */
+    readonly name: StringType;
+    /** Parameter kind (int, float, categorical, log_uniform) */
+    readonly kind: VariantType<{
+        /** Integer parameter with low/high bounds */
+        readonly int: NullType;
+        /** Float parameter with low/high bounds */
+        readonly float: NullType;
+        /** Categorical parameter with choices */
+        readonly categorical: NullType;
+        /** Log-uniform float parameter (for learning rates, etc.) */
+        readonly log_uniform: NullType;
+    }>;
+    /** Lower bound (for int, float, log_uniform) */
+    readonly low: OptionType<FloatType>;
+    /** Upper bound (for int, float, log_uniform) */
+    readonly high: OptionType<FloatType>;
+    /** Choices (for categorical) */
+    readonly choices: OptionType<ArrayType<VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
+    }>>>;
+}>;
+/**
+ * Named parameter (name + value pair).
+ *
+ * Represents a single parameter with its suggested/best value.
+ */
+export declare const NamedParamType: StructType<{
+    /** Parameter name */
+    readonly name: StringType;
+    /** Parameter value */
+    readonly value: VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
+    }>;
+}>;
+/**
+ * Optimization direction (minimize or maximize).
+ */
+export declare const OptimizationDirectionType: VariantType<{
+    readonly minimize: NullType;
+    readonly maximize: NullType;
+}>;
+/**
+ * Pruner type for early stopping of unpromising trials.
+ */
+export declare const PrunerType: VariantType<{
+    /** No pruning */
+    readonly none: NullType;
+    /** Median pruner - prune if below median of previous trials */
+    readonly median: NullType;
+    /** Hyperband pruner - aggressive early stopping */
+    readonly hyperband: NullType;
+}>;
+/**
+ * Optuna study configuration.
+ */
+export declare const OptunaStudyConfigType: StructType<{
+    /** Optimization direction (default: minimize) */
+    readonly direction: OptionType<VariantType<{
+        readonly minimize: NullType;
+        readonly maximize: NullType;
+    }>>;
+    /** Number of trials to run */
+    readonly n_trials: IntegerType;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Pruner for early stopping (default: none) */
+    readonly pruner: OptionType<VariantType<{
+        /** No pruning */
+        readonly none: NullType;
+        /** Median pruner - prune if below median of previous trials */
+        readonly median: NullType;
+        /** Hyperband pruner - aggressive early stopping */
+        readonly hyperband: NullType;
+    }>>;
+    /** Initial parameters to evaluate before sampling (warm-start) */
+    readonly initial_params: OptionType<ArrayType<StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter value */
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+    }>>>;
+}>;
+/**
+ * Single trial result.
+ */
+export declare const TrialResultType: StructType<{
+    /** Trial ID */
+    readonly trial_id: IntegerType;
+    /** Parameters used in this trial */
+    readonly params: ArrayType<StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter value */
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+    }>>;
+    /** Objective score */
+    readonly score: FloatType;
+}>;
+/**
+ * Optimization study result.
+ */
+export declare const StudyResultType: StructType<{
+    /** Best parameters found */
+    readonly best_params: ArrayType<StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter value */
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+    }>>;
+    /** Best objective score */
+    readonly best_score: FloatType;
+    /** All completed trials */
+    readonly trials: ArrayType<StructType<{
+        /** Trial ID */
+        readonly trial_id: IntegerType;
+        /** Parameters used in this trial */
+        readonly params: ArrayType<StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>>;
+        /** Objective score */
+        readonly score: FloatType;
+    }>>;
+}>;
+/**
+ * Objective function type: takes named params, returns score.
+ *
+ * The objective function is an East function that receives suggested
+ * parameters and returns a scalar score to minimize/maximize.
+ */
+export declare const ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
+    /** Parameter name */
+    readonly name: StringType;
+    /** Parameter value */
+    readonly value: VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
+    }>;
+}>>], FloatType>;
+/**
+ * Run Bayesian optimization with Optuna.
+ *
+ * Uses TPE (Tree-structured Parzen Estimator) to efficiently search
+ * the parameter space, balancing exploration and exploitation.
+ *
+ * @param search_space - Array of parameter space definitions
+ * @param objective - East function that takes params and returns score
+ * @param config - Study configuration (n_trials, direction, etc.)
+ * @returns Study result with best params, best score, and all trials
+ *
+ * @example
+ * ```ts
+ * import { East, FloatType, variant } from "@elaraai/east";
+ * import { Optuna } from "@elaraai/east-py-datascience";
+ *
+ * // Define objective: minimize (x - 2)^2 + (y - 3)^2
+ * const objective = East.function(
+ *     [ArrayType(Optuna.Types.NamedParamType)],
+ *     FloatType,
+ *     ($, params) => {
+ *         // Extract params by name
+ *         const x = $.let(params.get(0n).value); // First param
+ *         const y = $.let(params.get(1n).value); // Second param
+ *         // Compute objective (assuming float params)
+ *         return $.return(
+ *             x.match({ float: v => v }).subtract(2.0).multiply(
+ *                 x.match({ float: v => v }).subtract(2.0)
+ *             ).add(
+ *                 y.match({ float: v => v }).subtract(3.0).multiply(
+ *                     y.match({ float: v => v }).subtract(3.0)
+ *                 )
+ *             )
+ *         );
+ *     }
+ * );
+ *
+ * const optimize = East.function([], Optuna.Types.StudyResultType, $ => {
+ *     const search_space = $.let([
+ *         { name: "x", kind: variant("float", null), low: variant("some", 0.0), high: variant("some", 5.0), choices: variant("none", null) },
+ *         { name: "y", kind: variant("float", null), low: variant("some", 0.0), high: variant("some", 5.0), choices: variant("none", null) },
+ *     ]);
+ *     const config = $.let({
+ *         direction: variant("some", variant("minimize", null)),
+ *         n_trials: 50n,
+ *         random_state: variant("some", 42n),
+ *         pruner: variant("none", null),
+ *     });
+ *     return $.return(Optuna.optimize(search_space, objective, config));
+ * });
+ * ```
+ */
+export declare const optuna_optimize: import("@elaraai/east").PlatformDefinition<[ArrayType<StructType<{
+    /** Parameter name */
+    readonly name: StringType;
+    /** Parameter kind (int, float, categorical, log_uniform) */
+    readonly kind: VariantType<{
+        /** Integer parameter with low/high bounds */
+        readonly int: NullType;
+        /** Float parameter with low/high bounds */
+        readonly float: NullType;
+        /** Categorical parameter with choices */
+        readonly categorical: NullType;
+        /** Log-uniform float parameter (for learning rates, etc.) */
+        readonly log_uniform: NullType;
+    }>;
+    /** Lower bound (for int, float, log_uniform) */
+    readonly low: OptionType<FloatType>;
+    /** Upper bound (for int, float, log_uniform) */
+    readonly high: OptionType<FloatType>;
+    /** Choices (for categorical) */
+    readonly choices: OptionType<ArrayType<VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
+    }>>>;
+}>>, FunctionType<[ArrayType<StructType<{
+    /** Parameter name */
+    readonly name: StringType;
+    /** Parameter value */
+    readonly value: VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
+    }>;
+}>>], FloatType>, StructType<{
+    /** Optimization direction (default: minimize) */
+    readonly direction: OptionType<VariantType<{
+        readonly minimize: NullType;
+        readonly maximize: NullType;
+    }>>;
+    /** Number of trials to run */
+    readonly n_trials: IntegerType;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Pruner for early stopping (default: none) */
+    readonly pruner: OptionType<VariantType<{
+        /** No pruning */
+        readonly none: NullType;
+        /** Median pruner - prune if below median of previous trials */
+        readonly median: NullType;
+        /** Hyperband pruner - aggressive early stopping */
+        readonly hyperband: NullType;
+    }>>;
+    /** Initial parameters to evaluate before sampling (warm-start) */
+    readonly initial_params: OptionType<ArrayType<StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter value */
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+    }>>>;
+}>], StructType<{
+    /** Best parameters found */
+    readonly best_params: ArrayType<StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter value */
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+    }>>;
+    /** Best objective score */
+    readonly best_score: FloatType;
+    /** All completed trials */
+    readonly trials: ArrayType<StructType<{
+        /** Trial ID */
+        readonly trial_id: IntegerType;
+        /** Parameters used in this trial */
+        readonly params: ArrayType<StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>>;
+        /** Objective score */
+        readonly score: FloatType;
+    }>>;
+}>>;
+/**
+ * Type definitions for Optuna optimization.
+ */
+export declare const OptunaTypes: {
+    /** Parameter value variant type */
+    readonly ParamValueType: VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
+    }>;
+    /** Parameter space kind type */
+    readonly ParamSpaceKindType: VariantType<{
+        /** Integer parameter with low/high bounds */
+        readonly int: NullType;
+        /** Float parameter with low/high bounds */
+        readonly float: NullType;
+        /** Categorical parameter with choices */
+        readonly categorical: NullType;
+        /** Log-uniform float parameter (for learning rates, etc.) */
+        readonly log_uniform: NullType;
+    }>;
+    /** Parameter space definition type */
+    readonly ParamSpaceType: StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter kind (int, float, categorical, log_uniform) */
+        readonly kind: VariantType<{
+            /** Integer parameter with low/high bounds */
+            readonly int: NullType;
+            /** Float parameter with low/high bounds */
+            readonly float: NullType;
+            /** Categorical parameter with choices */
+            readonly categorical: NullType;
+            /** Log-uniform float parameter (for learning rates, etc.) */
+            readonly log_uniform: NullType;
+        }>;
+        /** Lower bound (for int, float, log_uniform) */
+        readonly low: OptionType<FloatType>;
+        /** Upper bound (for int, float, log_uniform) */
+        readonly high: OptionType<FloatType>;
+        /** Choices (for categorical) */
+        readonly choices: OptionType<ArrayType<VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>>>;
+    }>;
+    /** Named parameter type */
+    readonly NamedParamType: StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter value */
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+    }>;
+    /** Optimization direction type */
+    readonly OptimizationDirectionType: VariantType<{
+        readonly minimize: NullType;
+        readonly maximize: NullType;
+    }>;
+    /** Pruner type */
+    readonly PrunerType: VariantType<{
+        /** No pruning */
+        readonly none: NullType;
+        /** Median pruner - prune if below median of previous trials */
+        readonly median: NullType;
+        /** Hyperband pruner - aggressive early stopping */
+        readonly hyperband: NullType;
+    }>;
+    /** Study config type */
+    readonly StudyConfigType: StructType<{
+        /** Optimization direction (default: minimize) */
+        readonly direction: OptionType<VariantType<{
+            readonly minimize: NullType;
+            readonly maximize: NullType;
+        }>>;
+        /** Number of trials to run */
+        readonly n_trials: IntegerType;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Pruner for early stopping (default: none) */
+        readonly pruner: OptionType<VariantType<{
+            /** No pruning */
+            readonly none: NullType;
+            /** Median pruner - prune if below median of previous trials */
+            readonly median: NullType;
+            /** Hyperband pruner - aggressive early stopping */
+            readonly hyperband: NullType;
+        }>>;
+        /** Initial parameters to evaluate before sampling (warm-start) */
+        readonly initial_params: OptionType<ArrayType<StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>>>;
+    }>;
+    /** Trial result type */
+    readonly TrialResultType: StructType<{
+        /** Trial ID */
+        readonly trial_id: IntegerType;
+        /** Parameters used in this trial */
+        readonly params: ArrayType<StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>>;
+        /** Objective score */
+        readonly score: FloatType;
+    }>;
+    /** Study result type */
+    readonly StudyResultType: StructType<{
+        /** Best parameters found */
+        readonly best_params: ArrayType<StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>>;
+        /** Best objective score */
+        readonly best_score: FloatType;
+        /** All completed trials */
+        readonly trials: ArrayType<StructType<{
+            /** Trial ID */
+            readonly trial_id: IntegerType;
+            /** Parameters used in this trial */
+            readonly params: ArrayType<StructType<{
+                /** Parameter name */
+                readonly name: StringType;
+                /** Parameter value */
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
+                }>;
+            }>>;
+            /** Objective score */
+            readonly score: FloatType;
+        }>>;
+    }>;
+    /** Objective function type */
+    readonly ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter value */
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+    }>>], FloatType>;
+};
+/**
+ * Bayesian optimization using Optuna.
+ *
+ * Provides efficient parameter optimization using TPE (Tree-structured
+ * Parzen Estimator) for blackbox functions with mixed parameter types.
+ *
+ * Supports:
+ * - Integer, float, and categorical parameters
+ * - Log-uniform sampling for learning rates
+ * - Minimization and maximization
+ * - Early stopping with pruners
+ *
+ * @example
+ * ```ts
+ * import { East, FloatType, variant } from "@elaraai/east";
+ * import { Optuna } from "@elaraai/east-py-datascience";
+ *
+ * const objective = East.function(
+ *     [ArrayType(Optuna.Types.NamedParamType)],
+ *     FloatType,
+ *     ($, params) => {
+ *         // Your objective function here
+ *         return $.return(score);
+ *     }
+ * );
+ *
+ * const result = Optuna.optimize(search_space, objective, config);
+ * ```
+ */
+export declare const Optuna: {
+    /**
+     * Run Bayesian optimization.
+     *
+     * Efficiently searches the parameter space using TPE.
+     */
+    readonly optimize: import("@elaraai/east").PlatformDefinition<[ArrayType<StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter kind (int, float, categorical, log_uniform) */
+        readonly kind: VariantType<{
+            /** Integer parameter with low/high bounds */
+            readonly int: NullType;
+            /** Float parameter with low/high bounds */
+            readonly float: NullType;
+            /** Categorical parameter with choices */
+            readonly categorical: NullType;
+            /** Log-uniform float parameter (for learning rates, etc.) */
+            readonly log_uniform: NullType;
+        }>;
+        /** Lower bound (for int, float, log_uniform) */
+        readonly low: OptionType<FloatType>;
+        /** Upper bound (for int, float, log_uniform) */
+        readonly high: OptionType<FloatType>;
+        /** Choices (for categorical) */
+        readonly choices: OptionType<ArrayType<VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>>>;
+    }>>, FunctionType<[ArrayType<StructType<{
+        /** Parameter name */
+        readonly name: StringType;
+        /** Parameter value */
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+    }>>], FloatType>, StructType<{
+        /** Optimization direction (default: minimize) */
+        readonly direction: OptionType<VariantType<{
+            readonly minimize: NullType;
+            readonly maximize: NullType;
+        }>>;
+        /** Number of trials to run */
+        readonly n_trials: IntegerType;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Pruner for early stopping (default: none) */
+        readonly pruner: OptionType<VariantType<{
+            /** No pruning */
+            readonly none: NullType;
+            /** Median pruner - prune if below median of previous trials */
+            readonly median: NullType;
+            /** Hyperband pruner - aggressive early stopping */
+            readonly hyperband: NullType;
+        }>>;
+        /** Initial parameters to evaluate before sampling (warm-start) */
+        readonly initial_params: OptionType<ArrayType<StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>>>;
+    }>], StructType<{
+        /** Best parameters found */
+        readonly best_params: ArrayType<StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>>;
+        /** Best objective score */
+        readonly best_score: FloatType;
+        /** All completed trials */
+        readonly trials: ArrayType<StructType<{
+            /** Trial ID */
+            readonly trial_id: IntegerType;
+            /** Parameters used in this trial */
+            readonly params: ArrayType<StructType<{
+                /** Parameter name */
+                readonly name: StringType;
+                /** Parameter value */
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
+                }>;
+            }>>;
+            /** Objective score */
+            readonly score: FloatType;
+        }>>;
+    }>>;
+    /**
+     * Type definitions for Optuna functions.
+     */
+    readonly Types: {
+        /** Parameter value variant type */
+        readonly ParamValueType: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
+        }>;
+        /** Parameter space kind type */
+        readonly ParamSpaceKindType: VariantType<{
+            /** Integer parameter with low/high bounds */
+            readonly int: NullType;
+            /** Float parameter with low/high bounds */
+            readonly float: NullType;
+            /** Categorical parameter with choices */
+            readonly categorical: NullType;
+            /** Log-uniform float parameter (for learning rates, etc.) */
+            readonly log_uniform: NullType;
+        }>;
+        /** Parameter space definition type */
+        readonly ParamSpaceType: StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter kind (int, float, categorical, log_uniform) */
+            readonly kind: VariantType<{
+                /** Integer parameter with low/high bounds */
+                readonly int: NullType;
+                /** Float parameter with low/high bounds */
+                readonly float: NullType;
+                /** Categorical parameter with choices */
+                readonly categorical: NullType;
+                /** Log-uniform float parameter (for learning rates, etc.) */
+                readonly log_uniform: NullType;
+            }>;
+            /** Lower bound (for int, float, log_uniform) */
+            readonly low: OptionType<FloatType>;
+            /** Upper bound (for int, float, log_uniform) */
+            readonly high: OptionType<FloatType>;
+            /** Choices (for categorical) */
+            readonly choices: OptionType<ArrayType<VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>>>;
+        }>;
+        /** Named parameter type */
+        readonly NamedParamType: StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>;
+        /** Optimization direction type */
+        readonly OptimizationDirectionType: VariantType<{
+            readonly minimize: NullType;
+            readonly maximize: NullType;
+        }>;
+        /** Pruner type */
+        readonly PrunerType: VariantType<{
+            /** No pruning */
+            readonly none: NullType;
+            /** Median pruner - prune if below median of previous trials */
+            readonly median: NullType;
+            /** Hyperband pruner - aggressive early stopping */
+            readonly hyperband: NullType;
+        }>;
+        /** Study config type */
+        readonly StudyConfigType: StructType<{
+            /** Optimization direction (default: minimize) */
+            readonly direction: OptionType<VariantType<{
+                readonly minimize: NullType;
+                readonly maximize: NullType;
+            }>>;
+            /** Number of trials to run */
+            readonly n_trials: IntegerType;
+            /** Random seed for reproducibility */
+            readonly random_state: OptionType<IntegerType>;
+            /** Pruner for early stopping (default: none) */
+            readonly pruner: OptionType<VariantType<{
+                /** No pruning */
+                readonly none: NullType;
+                /** Median pruner - prune if below median of previous trials */
+                readonly median: NullType;
+                /** Hyperband pruner - aggressive early stopping */
+                readonly hyperband: NullType;
+            }>>;
+            /** Initial parameters to evaluate before sampling (warm-start) */
+            readonly initial_params: OptionType<ArrayType<StructType<{
+                /** Parameter name */
+                readonly name: StringType;
+                /** Parameter value */
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
+                }>;
+            }>>>;
+        }>;
+        /** Trial result type */
+        readonly TrialResultType: StructType<{
+            /** Trial ID */
+            readonly trial_id: IntegerType;
+            /** Parameters used in this trial */
+            readonly params: ArrayType<StructType<{
+                /** Parameter name */
+                readonly name: StringType;
+                /** Parameter value */
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
+                }>;
+            }>>;
+            /** Objective score */
+            readonly score: FloatType;
+        }>;
+        /** Study result type */
+        readonly StudyResultType: StructType<{
+            /** Best parameters found */
+            readonly best_params: ArrayType<StructType<{
+                /** Parameter name */
+                readonly name: StringType;
+                /** Parameter value */
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
+                }>;
+            }>>;
+            /** Best objective score */
+            readonly best_score: FloatType;
+            /** All completed trials */
+            readonly trials: ArrayType<StructType<{
+                /** Trial ID */
+                readonly trial_id: IntegerType;
+                /** Parameters used in this trial */
+                readonly params: ArrayType<StructType<{
+                    /** Parameter name */
+                    readonly name: StringType;
+                    /** Parameter value */
+                    readonly value: VariantType<{
+                        readonly int: IntegerType;
+                        readonly float: FloatType;
+                        readonly string: StringType;
+                        readonly bool: BooleanType;
+                    }>;
+                }>>;
+                /** Objective score */
+                readonly score: FloatType;
+            }>>;
+        }>;
+        /** Objective function type */
+        readonly ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
+            /** Parameter name */
+            readonly name: StringType;
+            /** Parameter value */
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
+            }>;
+        }>>], FloatType>;
+    };
+};
+//# sourceMappingURL=optuna.d.ts.map