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

package/dist/{optuna → src/optuna}/optuna.d.ts

@@ -18,23 +18,23 @@ import { StructType, VariantType, OptionType, ArrayType, IntegerType, FloatType,
  * Parameter value type (can be int, float, string, or bool).
  */
 export declare const ParamValueType: VariantType<{
-    int: IntegerType;
-    float: FloatType;
-    string: StringType;
-    bool: BooleanType;
+    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 */
-    int: NullType;
+    readonly int: NullType;
     /** Float parameter with low/high bounds */
-    float: NullType;
+    readonly float: NullType;
     /** Categorical parameter with choices */
-    categorical: NullType;
+    readonly categorical: NullType;
     /** Log-uniform float parameter (for learning rates, etc.) */
-    log_uniform: NullType;
+    readonly log_uniform: NullType;
 }>;
 /**
  * Parameter search space definition.
@@ -43,28 +43,28 @@ export declare const ParamSpaceKindType: VariantType<{
  */
 export declare const ParamSpaceType: StructType<{
     /** Parameter name */
-    name: StringType;
+    readonly name: StringType;
     /** Parameter kind (int, float, categorical, log_uniform) */
-    kind: VariantType<{
+    readonly kind: VariantType<{
         /** Integer parameter with low/high bounds */
-        int: NullType;
+        readonly int: NullType;
         /** Float parameter with low/high bounds */
-        float: NullType;
+        readonly float: NullType;
         /** Categorical parameter with choices */
-        categorical: NullType;
+        readonly categorical: NullType;
         /** Log-uniform float parameter (for learning rates, etc.) */
-        log_uniform: NullType;
+        readonly log_uniform: NullType;
     }>;
     /** Lower bound (for int, float, log_uniform) */
-    low: OptionType<FloatType>;
+    readonly low: OptionType<FloatType>;
     /** Upper bound (for int, float, log_uniform) */
-    high: OptionType<FloatType>;
+    readonly high: OptionType<FloatType>;
     /** Choices (for categorical) */
-    choices: OptionType<ArrayType<VariantType<{
-        int: IntegerType;
-        float: FloatType;
-        string: StringType;
-        bool: BooleanType;
+    readonly choices: OptionType<ArrayType<VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
     }>>>;
 }>;
 /**
@@ -74,113 +74,125 @@ export declare const ParamSpaceType: StructType<{
  */
 export declare const NamedParamType: StructType<{
     /** Parameter name */
-    name: StringType;
+    readonly name: StringType;
     /** Parameter value */
-    value: VariantType<{
-        int: IntegerType;
-        float: FloatType;
-        string: StringType;
-        bool: BooleanType;
+    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<{
-    minimize: NullType;
-    maximize: NullType;
+    readonly minimize: NullType;
+    readonly maximize: NullType;
 }>;
 /**
  * Pruner type for early stopping of unpromising trials.
  */
 export declare const PrunerType: VariantType<{
     /** No pruning */
-    none: NullType;
+    readonly none: NullType;
     /** Median pruner - prune if below median of previous trials */
-    median: NullType;
+    readonly median: NullType;
     /** Hyperband pruner - aggressive early stopping */
-    hyperband: NullType;
+    readonly hyperband: NullType;
 }>;
 /**
  * Optuna study configuration.
  */
 export declare const OptunaStudyConfigType: StructType<{
     /** Optimization direction (default: minimize) */
-    direction: OptionType<VariantType<{
-        minimize: NullType;
-        maximize: NullType;
+    readonly direction: OptionType<VariantType<{
+        readonly minimize: NullType;
+        readonly maximize: NullType;
     }>>;
     /** Number of trials to run */
-    n_trials: IntegerType;
+    readonly n_trials: IntegerType;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly random_state: OptionType<IntegerType>;
     /** Pruner for early stopping (default: none) */
-    pruner: OptionType<VariantType<{
+    readonly pruner: OptionType<VariantType<{
         /** No pruning */
-        none: NullType;
+        readonly none: NullType;
         /** Median pruner - prune if below median of previous trials */
-        median: NullType;
+        readonly median: NullType;
         /** Hyperband pruner - aggressive early stopping */
-        hyperband: NullType;
+        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 */
-    trial_id: IntegerType;
+    readonly trial_id: IntegerType;
     /** Parameters used in this trial */
-    params: ArrayType<StructType<{
+    readonly params: ArrayType<StructType<{
         /** Parameter name */
-        name: StringType;
+        readonly name: StringType;
         /** Parameter value */
-        value: VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
         }>;
     }>>;
     /** Objective score */
-    score: FloatType;
+    readonly score: FloatType;
 }>;
 /**
  * Optimization study result.
  */
 export declare const StudyResultType: StructType<{
     /** Best parameters found */
-    best_params: ArrayType<StructType<{
+    readonly best_params: ArrayType<StructType<{
         /** Parameter name */
-        name: StringType;
+        readonly name: StringType;
         /** Parameter value */
-        value: VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
         }>;
     }>>;
     /** Best objective score */
-    best_score: FloatType;
+    readonly best_score: FloatType;
     /** All completed trials */
-    trials: ArrayType<StructType<{
+    readonly trials: ArrayType<StructType<{
         /** Trial ID */
-        trial_id: IntegerType;
+        readonly trial_id: IntegerType;
         /** Parameters used in this trial */
-        params: ArrayType<StructType<{
+        readonly params: ArrayType<StructType<{
             /** Parameter name */
-            name: StringType;
+            readonly name: StringType;
             /** Parameter value */
-            value: VariantType<{
-                int: IntegerType;
-                float: FloatType;
-                string: StringType;
-                bool: BooleanType;
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
             }>;
         }>>;
         /** Objective score */
-        score: FloatType;
+        readonly score: FloatType;
     }>>;
 }>;
 /**
@@ -191,13 +203,13 @@ export declare const StudyResultType: StructType<{
  */
 export declare const ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
     /** Parameter name */
-    name: StringType;
+    readonly name: StringType;
     /** Parameter value */
-    value: VariantType<{
-        int: IntegerType;
-        float: FloatType;
-        string: StringType;
-        bool: BooleanType;
+    readonly value: VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
     }>;
 }>>], FloatType>;
 /**
@@ -254,91 +266,103 @@ export declare const ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
  */
 export declare const optuna_optimize: import("@elaraai/east").PlatformDefinition<[ArrayType<StructType<{
     /** Parameter name */
-    name: StringType;
+    readonly name: StringType;
     /** Parameter kind (int, float, categorical, log_uniform) */
-    kind: VariantType<{
+    readonly kind: VariantType<{
         /** Integer parameter with low/high bounds */
-        int: NullType;
+        readonly int: NullType;
         /** Float parameter with low/high bounds */
-        float: NullType;
+        readonly float: NullType;
         /** Categorical parameter with choices */
-        categorical: NullType;
+        readonly categorical: NullType;
         /** Log-uniform float parameter (for learning rates, etc.) */
-        log_uniform: NullType;
+        readonly log_uniform: NullType;
     }>;
     /** Lower bound (for int, float, log_uniform) */
-    low: OptionType<FloatType>;
+    readonly low: OptionType<FloatType>;
     /** Upper bound (for int, float, log_uniform) */
-    high: OptionType<FloatType>;
+    readonly high: OptionType<FloatType>;
     /** Choices (for categorical) */
-    choices: OptionType<ArrayType<VariantType<{
-        int: IntegerType;
-        float: FloatType;
-        string: StringType;
-        bool: BooleanType;
+    readonly choices: OptionType<ArrayType<VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
     }>>>;
 }>>, FunctionType<[ArrayType<StructType<{
     /** Parameter name */
-    name: StringType;
+    readonly name: StringType;
     /** Parameter value */
-    value: VariantType<{
-        int: IntegerType;
-        float: FloatType;
-        string: StringType;
-        bool: BooleanType;
+    readonly value: VariantType<{
+        readonly int: IntegerType;
+        readonly float: FloatType;
+        readonly string: StringType;
+        readonly bool: BooleanType;
     }>;
 }>>], FloatType>, StructType<{
     /** Optimization direction (default: minimize) */
-    direction: OptionType<VariantType<{
-        minimize: NullType;
-        maximize: NullType;
+    readonly direction: OptionType<VariantType<{
+        readonly minimize: NullType;
+        readonly maximize: NullType;
     }>>;
     /** Number of trials to run */
-    n_trials: IntegerType;
+    readonly n_trials: IntegerType;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly random_state: OptionType<IntegerType>;
     /** Pruner for early stopping (default: none) */
-    pruner: OptionType<VariantType<{
+    readonly pruner: OptionType<VariantType<{
         /** No pruning */
-        none: NullType;
+        readonly none: NullType;
         /** Median pruner - prune if below median of previous trials */
-        median: NullType;
+        readonly median: NullType;
         /** Hyperband pruner - aggressive early stopping */
-        hyperband: NullType;
+        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 */
-    best_params: ArrayType<StructType<{
+    readonly best_params: ArrayType<StructType<{
         /** Parameter name */
-        name: StringType;
+        readonly name: StringType;
         /** Parameter value */
-        value: VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
         }>;
     }>>;
     /** Best objective score */
-    best_score: FloatType;
+    readonly best_score: FloatType;
     /** All completed trials */
-    trials: ArrayType<StructType<{
+    readonly trials: ArrayType<StructType<{
         /** Trial ID */
-        trial_id: IntegerType;
+        readonly trial_id: IntegerType;
         /** Parameters used in this trial */
-        params: ArrayType<StructType<{
+        readonly params: ArrayType<StructType<{
             /** Parameter name */
-            name: StringType;
+            readonly name: StringType;
             /** Parameter value */
-            value: VariantType<{
-                int: IntegerType;
-                float: FloatType;
-                string: StringType;
-                bool: BooleanType;
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
             }>;
         }>>;
         /** Objective score */
-        score: FloatType;
+        readonly score: FloatType;
     }>>;
 }>>;
 /**
@@ -347,161 +371,173 @@ export declare const optuna_optimize: import("@elaraai/east").PlatformDefinition
 export declare const OptunaTypes: {
     /** Parameter value variant type */
     readonly ParamValueType: VariantType<{
-        int: IntegerType;
-        float: FloatType;
-        string: StringType;
-        bool: BooleanType;
+        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 */
-        int: NullType;
+        readonly int: NullType;
         /** Float parameter with low/high bounds */
-        float: NullType;
+        readonly float: NullType;
         /** Categorical parameter with choices */
-        categorical: NullType;
+        readonly categorical: NullType;
         /** Log-uniform float parameter (for learning rates, etc.) */
-        log_uniform: NullType;
+        readonly log_uniform: NullType;
     }>;
     /** Parameter space definition type */
     readonly ParamSpaceType: StructType<{
         /** Parameter name */
-        name: StringType;
+        readonly name: StringType;
         /** Parameter kind (int, float, categorical, log_uniform) */
-        kind: VariantType<{
+        readonly kind: VariantType<{
             /** Integer parameter with low/high bounds */
-            int: NullType;
+            readonly int: NullType;
             /** Float parameter with low/high bounds */
-            float: NullType;
+            readonly float: NullType;
             /** Categorical parameter with choices */
-            categorical: NullType;
+            readonly categorical: NullType;
             /** Log-uniform float parameter (for learning rates, etc.) */
-            log_uniform: NullType;
+            readonly log_uniform: NullType;
         }>;
         /** Lower bound (for int, float, log_uniform) */
-        low: OptionType<FloatType>;
+        readonly low: OptionType<FloatType>;
         /** Upper bound (for int, float, log_uniform) */
-        high: OptionType<FloatType>;
+        readonly high: OptionType<FloatType>;
         /** Choices (for categorical) */
-        choices: OptionType<ArrayType<VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+        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 */
-        name: StringType;
+        readonly name: StringType;
         /** Parameter value */
-        value: VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
         }>;
     }>;
     /** Optimization direction type */
     readonly OptimizationDirectionType: VariantType<{
-        minimize: NullType;
-        maximize: NullType;
+        readonly minimize: NullType;
+        readonly maximize: NullType;
     }>;
     /** Pruner type */
     readonly PrunerType: VariantType<{
         /** No pruning */
-        none: NullType;
+        readonly none: NullType;
         /** Median pruner - prune if below median of previous trials */
-        median: NullType;
+        readonly median: NullType;
         /** Hyperband pruner - aggressive early stopping */
-        hyperband: NullType;
+        readonly hyperband: NullType;
     }>;
     /** Study config type */
     readonly StudyConfigType: StructType<{
         /** Optimization direction (default: minimize) */
-        direction: OptionType<VariantType<{
-            minimize: NullType;
-            maximize: NullType;
+        readonly direction: OptionType<VariantType<{
+            readonly minimize: NullType;
+            readonly maximize: NullType;
         }>>;
         /** Number of trials to run */
-        n_trials: IntegerType;
+        readonly n_trials: IntegerType;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly random_state: OptionType<IntegerType>;
         /** Pruner for early stopping (default: none) */
-        pruner: OptionType<VariantType<{
+        readonly pruner: OptionType<VariantType<{
             /** No pruning */
-            none: NullType;
+            readonly none: NullType;
             /** Median pruner - prune if below median of previous trials */
-            median: NullType;
+            readonly median: NullType;
             /** Hyperband pruner - aggressive early stopping */
-            hyperband: NullType;
+            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 */
-        trial_id: IntegerType;
+        readonly trial_id: IntegerType;
         /** Parameters used in this trial */
-        params: ArrayType<StructType<{
+        readonly params: ArrayType<StructType<{
             /** Parameter name */
-            name: StringType;
+            readonly name: StringType;
             /** Parameter value */
-            value: VariantType<{
-                int: IntegerType;
-                float: FloatType;
-                string: StringType;
-                bool: BooleanType;
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
             }>;
         }>>;
         /** Objective score */
-        score: FloatType;
+        readonly score: FloatType;
     }>;
     /** Study result type */
     readonly StudyResultType: StructType<{
         /** Best parameters found */
-        best_params: ArrayType<StructType<{
+        readonly best_params: ArrayType<StructType<{
             /** Parameter name */
-            name: StringType;
+            readonly name: StringType;
             /** Parameter value */
-            value: VariantType<{
-                int: IntegerType;
-                float: FloatType;
-                string: StringType;
-                bool: BooleanType;
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
             }>;
         }>>;
         /** Best objective score */
-        best_score: FloatType;
+        readonly best_score: FloatType;
         /** All completed trials */
-        trials: ArrayType<StructType<{
+        readonly trials: ArrayType<StructType<{
             /** Trial ID */
-            trial_id: IntegerType;
+            readonly trial_id: IntegerType;
             /** Parameters used in this trial */
-            params: ArrayType<StructType<{
+            readonly params: ArrayType<StructType<{
                 /** Parameter name */
-                name: StringType;
+                readonly name: StringType;
                 /** Parameter value */
-                value: VariantType<{
-                    int: IntegerType;
-                    float: FloatType;
-                    string: StringType;
-                    bool: BooleanType;
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
                 }>;
             }>>;
             /** Objective score */
-            score: FloatType;
+            readonly score: FloatType;
         }>>;
     }>;
     /** Objective function type */
     readonly ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
         /** Parameter name */
-        name: StringType;
+        readonly name: StringType;
         /** Parameter value */
-        value: VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
         }>;
     }>>], FloatType>;
 };
@@ -542,91 +578,103 @@ export declare const Optuna: {
      */
     readonly optimize: import("@elaraai/east").PlatformDefinition<[ArrayType<StructType<{
         /** Parameter name */
-        name: StringType;
+        readonly name: StringType;
         /** Parameter kind (int, float, categorical, log_uniform) */
-        kind: VariantType<{
+        readonly kind: VariantType<{
             /** Integer parameter with low/high bounds */
-            int: NullType;
+            readonly int: NullType;
             /** Float parameter with low/high bounds */
-            float: NullType;
+            readonly float: NullType;
             /** Categorical parameter with choices */
-            categorical: NullType;
+            readonly categorical: NullType;
             /** Log-uniform float parameter (for learning rates, etc.) */
-            log_uniform: NullType;
+            readonly log_uniform: NullType;
         }>;
         /** Lower bound (for int, float, log_uniform) */
-        low: OptionType<FloatType>;
+        readonly low: OptionType<FloatType>;
         /** Upper bound (for int, float, log_uniform) */
-        high: OptionType<FloatType>;
+        readonly high: OptionType<FloatType>;
         /** Choices (for categorical) */
-        choices: OptionType<ArrayType<VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+        readonly choices: OptionType<ArrayType<VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
         }>>>;
     }>>, FunctionType<[ArrayType<StructType<{
         /** Parameter name */
-        name: StringType;
+        readonly name: StringType;
         /** Parameter value */
-        value: VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+        readonly value: VariantType<{
+            readonly int: IntegerType;
+            readonly float: FloatType;
+            readonly string: StringType;
+            readonly bool: BooleanType;
         }>;
     }>>], FloatType>, StructType<{
         /** Optimization direction (default: minimize) */
-        direction: OptionType<VariantType<{
-            minimize: NullType;
-            maximize: NullType;
+        readonly direction: OptionType<VariantType<{
+            readonly minimize: NullType;
+            readonly maximize: NullType;
         }>>;
         /** Number of trials to run */
-        n_trials: IntegerType;
+        readonly n_trials: IntegerType;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly random_state: OptionType<IntegerType>;
         /** Pruner for early stopping (default: none) */
-        pruner: OptionType<VariantType<{
+        readonly pruner: OptionType<VariantType<{
             /** No pruning */
-            none: NullType;
+            readonly none: NullType;
             /** Median pruner - prune if below median of previous trials */
-            median: NullType;
+            readonly median: NullType;
             /** Hyperband pruner - aggressive early stopping */
-            hyperband: NullType;
+            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 */
-        best_params: ArrayType<StructType<{
+        readonly best_params: ArrayType<StructType<{
             /** Parameter name */
-            name: StringType;
+            readonly name: StringType;
             /** Parameter value */
-            value: VariantType<{
-                int: IntegerType;
-                float: FloatType;
-                string: StringType;
-                bool: BooleanType;
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
             }>;
         }>>;
         /** Best objective score */
-        best_score: FloatType;
+        readonly best_score: FloatType;
         /** All completed trials */
-        trials: ArrayType<StructType<{
+        readonly trials: ArrayType<StructType<{
             /** Trial ID */
-            trial_id: IntegerType;
+            readonly trial_id: IntegerType;
             /** Parameters used in this trial */
-            params: ArrayType<StructType<{
+            readonly params: ArrayType<StructType<{
                 /** Parameter name */
-                name: StringType;
+                readonly name: StringType;
                 /** Parameter value */
-                value: VariantType<{
-                    int: IntegerType;
-                    float: FloatType;
-                    string: StringType;
-                    bool: BooleanType;
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
                 }>;
             }>>;
             /** Objective score */
-            score: FloatType;
+            readonly score: FloatType;
         }>>;
     }>>;
     /**
@@ -635,161 +683,173 @@ export declare const Optuna: {
     readonly Types: {
         /** Parameter value variant type */
         readonly ParamValueType: VariantType<{
-            int: IntegerType;
-            float: FloatType;
-            string: StringType;
-            bool: BooleanType;
+            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 */
-            int: NullType;
+            readonly int: NullType;
             /** Float parameter with low/high bounds */
-            float: NullType;
+            readonly float: NullType;
             /** Categorical parameter with choices */
-            categorical: NullType;
+            readonly categorical: NullType;
             /** Log-uniform float parameter (for learning rates, etc.) */
-            log_uniform: NullType;
+            readonly log_uniform: NullType;
         }>;
         /** Parameter space definition type */
         readonly ParamSpaceType: StructType<{
             /** Parameter name */
-            name: StringType;
+            readonly name: StringType;
             /** Parameter kind (int, float, categorical, log_uniform) */
-            kind: VariantType<{
+            readonly kind: VariantType<{
                 /** Integer parameter with low/high bounds */
-                int: NullType;
+                readonly int: NullType;
                 /** Float parameter with low/high bounds */
-                float: NullType;
+                readonly float: NullType;
                 /** Categorical parameter with choices */
-                categorical: NullType;
+                readonly categorical: NullType;
                 /** Log-uniform float parameter (for learning rates, etc.) */
-                log_uniform: NullType;
+                readonly log_uniform: NullType;
             }>;
             /** Lower bound (for int, float, log_uniform) */
-            low: OptionType<FloatType>;
+            readonly low: OptionType<FloatType>;
             /** Upper bound (for int, float, log_uniform) */
-            high: OptionType<FloatType>;
+            readonly high: OptionType<FloatType>;
             /** Choices (for categorical) */
-            choices: OptionType<ArrayType<VariantType<{
-                int: IntegerType;
-                float: FloatType;
-                string: StringType;
-                bool: BooleanType;
+            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 */
-            name: StringType;
+            readonly name: StringType;
             /** Parameter value */
-            value: VariantType<{
-                int: IntegerType;
-                float: FloatType;
-                string: StringType;
-                bool: BooleanType;
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
             }>;
         }>;
         /** Optimization direction type */
         readonly OptimizationDirectionType: VariantType<{
-            minimize: NullType;
-            maximize: NullType;
+            readonly minimize: NullType;
+            readonly maximize: NullType;
         }>;
         /** Pruner type */
         readonly PrunerType: VariantType<{
             /** No pruning */
-            none: NullType;
+            readonly none: NullType;
             /** Median pruner - prune if below median of previous trials */
-            median: NullType;
+            readonly median: NullType;
             /** Hyperband pruner - aggressive early stopping */
-            hyperband: NullType;
+            readonly hyperband: NullType;
         }>;
         /** Study config type */
         readonly StudyConfigType: StructType<{
             /** Optimization direction (default: minimize) */
-            direction: OptionType<VariantType<{
-                minimize: NullType;
-                maximize: NullType;
+            readonly direction: OptionType<VariantType<{
+                readonly minimize: NullType;
+                readonly maximize: NullType;
             }>>;
             /** Number of trials to run */
-            n_trials: IntegerType;
+            readonly n_trials: IntegerType;
             /** Random seed for reproducibility */
-            random_state: OptionType<IntegerType>;
+            readonly random_state: OptionType<IntegerType>;
             /** Pruner for early stopping (default: none) */
-            pruner: OptionType<VariantType<{
+            readonly pruner: OptionType<VariantType<{
                 /** No pruning */
-                none: NullType;
+                readonly none: NullType;
                 /** Median pruner - prune if below median of previous trials */
-                median: NullType;
+                readonly median: NullType;
                 /** Hyperband pruner - aggressive early stopping */
-                hyperband: NullType;
+                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 */
-            trial_id: IntegerType;
+            readonly trial_id: IntegerType;
             /** Parameters used in this trial */
-            params: ArrayType<StructType<{
+            readonly params: ArrayType<StructType<{
                 /** Parameter name */
-                name: StringType;
+                readonly name: StringType;
                 /** Parameter value */
-                value: VariantType<{
-                    int: IntegerType;
-                    float: FloatType;
-                    string: StringType;
-                    bool: BooleanType;
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
                 }>;
             }>>;
             /** Objective score */
-            score: FloatType;
+            readonly score: FloatType;
         }>;
         /** Study result type */
         readonly StudyResultType: StructType<{
             /** Best parameters found */
-            best_params: ArrayType<StructType<{
+            readonly best_params: ArrayType<StructType<{
                 /** Parameter name */
-                name: StringType;
+                readonly name: StringType;
                 /** Parameter value */
-                value: VariantType<{
-                    int: IntegerType;
-                    float: FloatType;
-                    string: StringType;
-                    bool: BooleanType;
+                readonly value: VariantType<{
+                    readonly int: IntegerType;
+                    readonly float: FloatType;
+                    readonly string: StringType;
+                    readonly bool: BooleanType;
                 }>;
             }>>;
             /** Best objective score */
-            best_score: FloatType;
+            readonly best_score: FloatType;
             /** All completed trials */
-            trials: ArrayType<StructType<{
+            readonly trials: ArrayType<StructType<{
                 /** Trial ID */
-                trial_id: IntegerType;
+                readonly trial_id: IntegerType;
                 /** Parameters used in this trial */
-                params: ArrayType<StructType<{
+                readonly params: ArrayType<StructType<{
                     /** Parameter name */
-                    name: StringType;
+                    readonly name: StringType;
                     /** Parameter value */
-                    value: VariantType<{
-                        int: IntegerType;
-                        float: FloatType;
-                        string: StringType;
-                        bool: BooleanType;
+                    readonly value: VariantType<{
+                        readonly int: IntegerType;
+                        readonly float: FloatType;
+                        readonly string: StringType;
+                        readonly bool: BooleanType;
                     }>;
                 }>>;
                 /** Objective score */
-                score: FloatType;
+                readonly score: FloatType;
             }>>;
         }>;
         /** Objective function type */
         readonly ObjectiveFunctionType: FunctionType<[ArrayType<StructType<{
             /** Parameter name */
-            name: StringType;
+            readonly name: StringType;
             /** Parameter value */
-            value: VariantType<{
-                int: IntegerType;
-                float: FloatType;
-                string: StringType;
-                bool: BooleanType;
+            readonly value: VariantType<{
+                readonly int: IntegerType;
+                readonly float: FloatType;
+                readonly string: StringType;
+                readonly bool: BooleanType;
             }>;
         }>>], FloatType>;
     };