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

package/dist/optuna/optuna.d.ts

@@ -0,0 +1,797 @@
+/**
+ * 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<{
+    int: IntegerType;
+    float: FloatType;
+    string: StringType;
+    bool: BooleanType;
+}>;
+/**
+ * Parameter space kind for defining search spaces.
+ */
+export declare const ParamSpaceKindType: VariantType<{
+    /** Integer parameter with low/high bounds */
+    int: NullType;
+    /** Float parameter with low/high bounds */
+    float: NullType;
+    /** Categorical parameter with choices */
+    categorical: NullType;
+    /** Log-uniform float parameter (for learning rates, etc.) */
+    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 */
+    name: StringType;
+    /** Parameter kind (int, float, categorical, log_uniform) */
+    kind: VariantType<{
+        /** Integer parameter with low/high bounds */
+        int: NullType;
+        /** Float parameter with low/high bounds */
+        float: NullType;
+        /** Categorical parameter with choices */
+        categorical: NullType;
+        /** Log-uniform float parameter (for learning rates, etc.) */
+        log_uniform: NullType;
+    }>;
+    /** Lower bound (for int, float, log_uniform) */
+    low: OptionType<FloatType>;
+    /** Upper bound (for int, float, log_uniform) */
+    high: OptionType<FloatType>;
+    /** Choices (for categorical) */
+    choices: OptionType<ArrayType<VariantType<{
+        int: IntegerType;
+        float: FloatType;
+        string: StringType;
+        bool: BooleanType;
+    }>>>;
+}>;
+/**
+ * Named parameter (name + value pair).
+ *
+ * Represents a single parameter with its suggested/best value.
+ */
+export declare const NamedParamType: StructType<{
+    /** Parameter name */
+    name: StringType;
+    /** Parameter value */
+    value: VariantType<{
+        int: IntegerType;
+        float: FloatType;
+        string: StringType;
+        bool: BooleanType;
+    }>;
+}>;
+/**
+ * Optimization direction (minimize or maximize).
+ */
+export declare const OptimizationDirectionType: VariantType<{
+    minimize: NullType;
+    maximize: NullType;
+}>;
+/**
+ * Pruner type for early stopping of unpromising trials.
+ */
+export declare const PrunerType: VariantType<{
+    /** No pruning */
+    none: NullType;
+    /** Median pruner - prune if below median of previous trials */
+    median: NullType;
+    /** Hyperband pruner - aggressive early stopping */
+    hyperband: NullType;
+}>;
+/**
+ * Optuna study configuration.
+ */
+export declare const OptunaStudyConfigType: StructType<{
+    /** Optimization direction (default: minimize) */
+    direction: OptionType<VariantType<{
+        minimize: NullType;
+        maximize: NullType;
+    }>>;
+    /** Number of trials to run */
+    n_trials: IntegerType;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Pruner for early stopping (default: none) */
+    pruner: OptionType<VariantType<{
+        /** No pruning */
+        none: NullType;
+        /** Median pruner - prune if below median of previous trials */
+        median: NullType;
+        /** Hyperband pruner - aggressive early stopping */
+        hyperband: NullType;
+    }>>;
+}>;
+/**
+ * Single trial result.
+ */
+export declare const TrialResultType: StructType<{
+    /** Trial ID */
+    trial_id: IntegerType;
+    /** Parameters used in this trial */
+    params: ArrayType<StructType<{
+        /** Parameter name */
+        name: StringType;
+        /** Parameter value */
+        value: VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            bool: BooleanType;
+        }>;
+    }>>;
+    /** Objective score */
+    score: FloatType;
+}>;
+/**
+ * Optimization study result.
+ */
+export declare const StudyResultType: StructType<{
+    /** Best parameters found */
+    best_params: ArrayType<StructType<{
+        /** Parameter name */
+        name: StringType;
+        /** Parameter value */
+        value: VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            bool: BooleanType;
+        }>;
+    }>>;
+    /** Best objective score */
+    best_score: FloatType;
+    /** All completed trials */
+    trials: ArrayType<StructType<{
+        /** Trial ID */
+        trial_id: IntegerType;
+        /** Parameters used in this trial */
+        params: ArrayType<StructType<{
+            /** Parameter name */
+            name: StringType;
+            /** Parameter value */
+            value: VariantType<{
+                int: IntegerType;
+                float: FloatType;
+                string: StringType;
+                bool: BooleanType;
+            }>;
+        }>>;
+        /** Objective score */
+        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 */
+    name: StringType;
+    /** Parameter value */
+    value: VariantType<{
+        int: IntegerType;
+        float: FloatType;
+        string: StringType;
+        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 */
+    name: StringType;
+    /** Parameter kind (int, float, categorical, log_uniform) */
+    kind: VariantType<{
+        /** Integer parameter with low/high bounds */
+        int: NullType;
+        /** Float parameter with low/high bounds */
+        float: NullType;
+        /** Categorical parameter with choices */
+        categorical: NullType;
+        /** Log-uniform float parameter (for learning rates, etc.) */
+        log_uniform: NullType;
+    }>;
+    /** Lower bound (for int, float, log_uniform) */
+    low: OptionType<FloatType>;
+    /** Upper bound (for int, float, log_uniform) */
+    high: OptionType<FloatType>;
+    /** Choices (for categorical) */
+    choices: OptionType<ArrayType<VariantType<{
+        int: IntegerType;
+        float: FloatType;
+        string: StringType;
+        bool: BooleanType;
+    }>>>;
+}>>, FunctionType<[ArrayType<StructType<{
+    /** Parameter name */
+    name: StringType;
+    /** Parameter value */
+    value: VariantType<{
+        int: IntegerType;
+        float: FloatType;
+        string: StringType;
+        bool: BooleanType;
+    }>;
+}>>], FloatType>, StructType<{
+    /** Optimization direction (default: minimize) */
+    direction: OptionType<VariantType<{
+        minimize: NullType;
+        maximize: NullType;
+    }>>;
+    /** Number of trials to run */
+    n_trials: IntegerType;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Pruner for early stopping (default: none) */
+    pruner: OptionType<VariantType<{
+        /** No pruning */
+        none: NullType;
+        /** Median pruner - prune if below median of previous trials */
+        median: NullType;
+        /** Hyperband pruner - aggressive early stopping */
+        hyperband: NullType;
+    }>>;
+}>], StructType<{
+    /** Best parameters found */
+    best_params: ArrayType<StructType<{
+        /** Parameter name */
+        name: StringType;
+        /** Parameter value */
+        value: VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            bool: BooleanType;
+        }>;
+    }>>;
+    /** Best objective score */
+    best_score: FloatType;
+    /** All completed trials */
+    trials: ArrayType<StructType<{
+        /** Trial ID */
+        trial_id: IntegerType;
+        /** Parameters used in this trial */
+        params: ArrayType<StructType<{
+            /** Parameter name */
+            name: StringType;
+            /** Parameter value */
+            value: VariantType<{
+                int: IntegerType;
+                float: FloatType;
+                string: StringType;
+                bool: BooleanType;
+            }>;
+        }>>;
+        /** Objective score */
+        score: FloatType;
+    }>>;
+}>>;
+/**
+ * Type definitions for Optuna optimization.
+ */
+export declare const OptunaTypes: {
+    /** Parameter value variant type */
+    readonly ParamValueType: VariantType<{
+        int: IntegerType;
+        float: FloatType;
+        string: StringType;
+        bool: BooleanType;
+    }>;
+    /** Parameter space kind type */
+    readonly ParamSpaceKindType: VariantType<{
+        /** Integer parameter with low/high bounds */
+        int: NullType;
+        /** Float parameter with low/high bounds */
+        float: NullType;
+        /** Categorical parameter with choices */
+        categorical: NullType;
+        /** Log-uniform float parameter (for learning rates, etc.) */
+        log_uniform: NullType;
+    }>;
+    /** Parameter space definition type */
+    readonly ParamSpaceType: StructType<{
+        /** Parameter name */
+        name: StringType;
+        /** Parameter kind (int, float, categorical, log_uniform) */
+        kind: VariantType<{
+            /** Integer parameter with low/high bounds */
+            int: NullType;
+            /** Float parameter with low/high bounds */
+            float: NullType;
+            /** Categorical parameter with choices */
+            categorical: NullType;
+            /** Log-uniform float parameter (for learning rates, etc.) */
+            log_uniform: NullType;
+        }>;
+        /** Lower bound (for int, float, log_uniform) */
+        low: OptionType<FloatType>;
+        /** Upper bound (for int, float, log_uniform) */
+        high: OptionType<FloatType>;
+        /** Choices (for categorical) */
+        choices: OptionType<ArrayType<VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            bool: BooleanType;
+        }>>>;
+    }>;
+    /** Named parameter type */
+    readonly NamedParamType: StructType<{
+        /** Parameter name */
+        name: StringType;
+        /** Parameter value */
+        value: VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            bool: BooleanType;
+        }>;
+    }>;
+    /** Optimization direction type */
+    readonly OptimizationDirectionType: VariantType<{
+        minimize: NullType;
+        maximize: NullType;
+    }>;
+    /** Pruner type */
+    readonly PrunerType: VariantType<{
+        /** No pruning */
+        none: NullType;
+        /** Median pruner - prune if below median of previous trials */
+        median: NullType;
+        /** Hyperband pruner - aggressive early stopping */
+        hyperband: NullType;
+    }>;
+    /** Study config type */
+    readonly StudyConfigType: StructType<{
+        /** Optimization direction (default: minimize) */
+        direction: OptionType<VariantType<{
+            minimize: NullType;
+            maximize: NullType;
+        }>>;
+        /** Number of trials to run */
+        n_trials: IntegerType;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Pruner for early stopping (default: none) */
+        pruner: OptionType<VariantType<{
+            /** No pruning */
+            none: NullType;
+            /** Median pruner - prune if below median of previous trials */
+            median: NullType;
+            /** Hyperband pruner - aggressive early stopping */
+            hyperband: NullType;
+        }>>;
+    }>;
+    /** Trial result type */
+    readonly TrialResultType: StructType<{
+        /** Trial ID */
+        trial_id: IntegerType;
+        /** Parameters used in this trial */
+        params: ArrayType<StructType<{
+            /** Parameter name */
+            name: StringType;
+            /** Parameter value */
+            value: VariantType<{
+                int: IntegerType;
+                float: FloatType;
+                string: StringType;
+                bool: BooleanType;
+            }>;
+        }>>;
+        /** Objective score */
+        score: FloatType;
+    }>;
+    /** Study result type */
+    readonly StudyResultType: StructType<{
+        /** Best parameters found */
+        best_params: ArrayType<StructType<{
+            /** Parameter name */
+            name: StringType;
+            /** Parameter value */
+            value: VariantType<{
+                int: IntegerType;
+                float: FloatType;
+                string: StringType;
+                bool: BooleanType;
+            }>;
+        }>>;
+        /** Best objective score */
+        best_score: FloatType;
+        /** All completed trials */
+        trials: ArrayType<StructType<{
+            /** Trial ID */
+            trial_id: IntegerType;
+            /** Parameters used in this trial */
+            params: ArrayType<StructType<{
+                /** Parameter name */
+                name: StringType;
+                /** Parameter value */
+                value: VariantType<{
+                    int: IntegerType;
+                    float: FloatType;
+                    string: StringType;
+                    bool: BooleanType;
+                }>;
+            }>>;
+            /** Objective score */
+            score: FloatType;
+        }>>;
+    }>;
+    /** Objective function type */
+    readonly ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
+        /** Parameter name */
+        name: StringType;
+        /** Parameter value */
+        value: VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            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 */
+        name: StringType;
+        /** Parameter kind (int, float, categorical, log_uniform) */
+        kind: VariantType<{
+            /** Integer parameter with low/high bounds */
+            int: NullType;
+            /** Float parameter with low/high bounds */
+            float: NullType;
+            /** Categorical parameter with choices */
+            categorical: NullType;
+            /** Log-uniform float parameter (for learning rates, etc.) */
+            log_uniform: NullType;
+        }>;
+        /** Lower bound (for int, float, log_uniform) */
+        low: OptionType<FloatType>;
+        /** Upper bound (for int, float, log_uniform) */
+        high: OptionType<FloatType>;
+        /** Choices (for categorical) */
+        choices: OptionType<ArrayType<VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            bool: BooleanType;
+        }>>>;
+    }>>, FunctionType<[ArrayType<StructType<{
+        /** Parameter name */
+        name: StringType;
+        /** Parameter value */
+        value: VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            bool: BooleanType;
+        }>;
+    }>>], FloatType>, StructType<{
+        /** Optimization direction (default: minimize) */
+        direction: OptionType<VariantType<{
+            minimize: NullType;
+            maximize: NullType;
+        }>>;
+        /** Number of trials to run */
+        n_trials: IntegerType;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Pruner for early stopping (default: none) */
+        pruner: OptionType<VariantType<{
+            /** No pruning */
+            none: NullType;
+            /** Median pruner - prune if below median of previous trials */
+            median: NullType;
+            /** Hyperband pruner - aggressive early stopping */
+            hyperband: NullType;
+        }>>;
+    }>], StructType<{
+        /** Best parameters found */
+        best_params: ArrayType<StructType<{
+            /** Parameter name */
+            name: StringType;
+            /** Parameter value */
+            value: VariantType<{
+                int: IntegerType;
+                float: FloatType;
+                string: StringType;
+                bool: BooleanType;
+            }>;
+        }>>;
+        /** Best objective score */
+        best_score: FloatType;
+        /** All completed trials */
+        trials: ArrayType<StructType<{
+            /** Trial ID */
+            trial_id: IntegerType;
+            /** Parameters used in this trial */
+            params: ArrayType<StructType<{
+                /** Parameter name */
+                name: StringType;
+                /** Parameter value */
+                value: VariantType<{
+                    int: IntegerType;
+                    float: FloatType;
+                    string: StringType;
+                    bool: BooleanType;
+                }>;
+            }>>;
+            /** Objective score */
+            score: FloatType;
+        }>>;
+    }>>;
+    /**
+     * Type definitions for Optuna functions.
+     */
+    readonly Types: {
+        /** Parameter value variant type */
+        readonly ParamValueType: VariantType<{
+            int: IntegerType;
+            float: FloatType;
+            string: StringType;
+            bool: BooleanType;
+        }>;
+        /** Parameter space kind type */
+        readonly ParamSpaceKindType: VariantType<{
+            /** Integer parameter with low/high bounds */
+            int: NullType;
+            /** Float parameter with low/high bounds */
+            float: NullType;
+            /** Categorical parameter with choices */
+            categorical: NullType;
+            /** Log-uniform float parameter (for learning rates, etc.) */
+            log_uniform: NullType;
+        }>;
+        /** Parameter space definition type */
+        readonly ParamSpaceType: StructType<{
+            /** Parameter name */
+            name: StringType;
+            /** Parameter kind (int, float, categorical, log_uniform) */
+            kind: VariantType<{
+                /** Integer parameter with low/high bounds */
+                int: NullType;
+                /** Float parameter with low/high bounds */
+                float: NullType;
+                /** Categorical parameter with choices */
+                categorical: NullType;
+                /** Log-uniform float parameter (for learning rates, etc.) */
+                log_uniform: NullType;
+            }>;
+            /** Lower bound (for int, float, log_uniform) */
+            low: OptionType<FloatType>;
+            /** Upper bound (for int, float, log_uniform) */
+            high: OptionType<FloatType>;
+            /** Choices (for categorical) */
+            choices: OptionType<ArrayType<VariantType<{
+                int: IntegerType;
+                float: FloatType;
+                string: StringType;
+                bool: BooleanType;
+            }>>>;
+        }>;
+        /** Named parameter type */
+        readonly NamedParamType: StructType<{
+            /** Parameter name */
+            name: StringType;
+            /** Parameter value */
+            value: VariantType<{
+                int: IntegerType;
+                float: FloatType;
+                string: StringType;
+                bool: BooleanType;
+            }>;
+        }>;
+        /** Optimization direction type */
+        readonly OptimizationDirectionType: VariantType<{
+            minimize: NullType;
+            maximize: NullType;
+        }>;
+        /** Pruner type */
+        readonly PrunerType: VariantType<{
+            /** No pruning */
+            none: NullType;
+            /** Median pruner - prune if below median of previous trials */
+            median: NullType;
+            /** Hyperband pruner - aggressive early stopping */
+            hyperband: NullType;
+        }>;
+        /** Study config type */
+        readonly StudyConfigType: StructType<{
+            /** Optimization direction (default: minimize) */
+            direction: OptionType<VariantType<{
+                minimize: NullType;
+                maximize: NullType;
+            }>>;
+            /** Number of trials to run */
+            n_trials: IntegerType;
+            /** Random seed for reproducibility */
+            random_state: OptionType<IntegerType>;
+            /** Pruner for early stopping (default: none) */
+            pruner: OptionType<VariantType<{
+                /** No pruning */
+                none: NullType;
+                /** Median pruner - prune if below median of previous trials */
+                median: NullType;
+                /** Hyperband pruner - aggressive early stopping */
+                hyperband: NullType;
+            }>>;
+        }>;
+        /** Trial result type */
+        readonly TrialResultType: StructType<{
+            /** Trial ID */
+            trial_id: IntegerType;
+            /** Parameters used in this trial */
+            params: ArrayType<StructType<{
+                /** Parameter name */
+                name: StringType;
+                /** Parameter value */
+                value: VariantType<{
+                    int: IntegerType;
+                    float: FloatType;
+                    string: StringType;
+                    bool: BooleanType;
+                }>;
+            }>>;
+            /** Objective score */
+            score: FloatType;
+        }>;
+        /** Study result type */
+        readonly StudyResultType: StructType<{
+            /** Best parameters found */
+            best_params: ArrayType<StructType<{
+                /** Parameter name */
+                name: StringType;
+                /** Parameter value */
+                value: VariantType<{
+                    int: IntegerType;
+                    float: FloatType;
+                    string: StringType;
+                    bool: BooleanType;
+                }>;
+            }>>;
+            /** Best objective score */
+            best_score: FloatType;
+            /** All completed trials */
+            trials: ArrayType<StructType<{
+                /** Trial ID */
+                trial_id: IntegerType;
+                /** Parameters used in this trial */
+                params: ArrayType<StructType<{
+                    /** Parameter name */
+                    name: StringType;
+                    /** Parameter value */
+                    value: VariantType<{
+                        int: IntegerType;
+                        float: FloatType;
+                        string: StringType;
+                        bool: BooleanType;
+                    }>;
+                }>>;
+                /** Objective score */
+                score: FloatType;
+            }>>;
+        }>;
+        /** Objective function type */
+        readonly ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
+            /** Parameter name */
+            name: StringType;
+            /** Parameter value */
+            value: VariantType<{
+                int: IntegerType;
+                float: FloatType;
+                string: StringType;
+                bool: BooleanType;
+            }>;
+        }>>], FloatType>;
+    };
+};
+//# sourceMappingURL=optuna.d.ts.map