@elaraai/e3-ui 1.0.102 → 1.0.104

package/dist/test/experiment/experiment.examples.d.ts

@@ -1,1512 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/** @jsxImportSource @elaraai/e3-ui */
-/**
- * Experiment component example — an interactive causal-experiment surface over a
- * generic manufacturing process. The worked question is *"did `slow_cure` change
- * `bond_strength`?"* — a confounding-by-indication story: the optional slow-cure
- * step is applied to the weaker incoming material, so the raw average makes it
- * look worse (−3.1) while the like-for-like estimate flips it positive (+5.2),
- * and the honesty verdict is `causal`.
- *
- * Pattern (the real, interactive shape — not a mock):
- *   1. `e3.input('batches', Array(BatchRow), variant('value', [...]))` — the **input dataset**. The
- *      renderer introspects this row struct to drive the treatment / outcome /
- *      confounder pickers, exactly like `Table`.
- *   2. `e3.input('experiment_configs', Array(Configuration), variant('value', [...]))` — the list of
- *      **questions**. Each entry is self-contained: a full `spec`
- *      ({@link Experiment.Types.Config}) and an OPTIONAL precomputed `result`
- *      (+ `design`). Selecting one seeds the working config.
- *   3. An OPTIONAL `e3.function('experiment', (rows, config) → ExperimentResult)`.
- *      One universal estimator serves every question; omit it when every shown
- *      config carries a precomputed `result`. Here it returns the constants the
- *      real `Causal.experiment` engine would, so the surface runs offline.
- *   4. `<Experiment data configs experiment journal />`. The renderer selects the
- *      first config, auto-runs (unless it has a precomputed result), derives every
- *      word / colour / bar from the single result + its `verdict`, and re-runs when
- *      the user edits the config.
- */
-import { ArrayType, StructType, BooleanType, FloatType, IntegerType, StringType, DateTimeType, variant } from '@elaraai/east';
-/** One production batch — the row struct the pickers are generic over. */
-export declare const BatchRow: StructType<{
-    readonly slow_cure: BooleanType;
-    readonly bond_strength: FloatType;
-    readonly incoming_grade: FloatType;
-    readonly mix_viscosity: FloatType;
-    readonly supplier: IntegerType;
-    readonly line: StringType;
-    readonly product: StringType;
-    readonly run_date: DateTimeType;
-}>;
-export declare const batchesInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly slow_cure: BooleanType;
-    readonly bond_strength: FloatType;
-    readonly incoming_grade: FloatType;
-    readonly mix_viscosity: FloatType;
-    readonly supplier: IntegerType;
-    readonly line: StringType;
-    readonly product: StringType;
-    readonly run_date: DateTimeType;
-}>>, [variant<"field", "inputs">, variant<"field", "batches">]>;
-export declare const experimentFn: import("@elaraai/e3").FunctionDef<[ArrayType<StructType<{
-    readonly slow_cure: BooleanType;
-    readonly bond_strength: FloatType;
-    readonly incoming_grade: FloatType;
-    readonly mix_viscosity: FloatType;
-    readonly supplier: IntegerType;
-    readonly line: StringType;
-    readonly product: StringType;
-    readonly run_date: DateTimeType;
-}>>, StructType<{
-    readonly treatment: StringType;
-    readonly outcome: StringType;
-    readonly common_causes: ArrayType<StringType>;
-    readonly categorical: import("@elaraai/east").OptionType<ArrayType<StringType>>;
-    readonly method: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly linear_regression: import("@elaraai/east").NullType;
-        readonly propensity_score_weighting: StructType<{
-            readonly weighting_scheme: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                readonly ips_weight: import("@elaraai/east").NullType;
-                readonly ips_stabilized_weight: import("@elaraai/east").NullType;
-                readonly ips_normalized_weight: import("@elaraai/east").NullType;
-            }>>;
-        }>;
-    }>>;
-    readonly estimand: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly ate: import("@elaraai/east").NullType;
-        readonly att: import("@elaraai/east").NullType;
-        readonly atc: import("@elaraai/east").NullType;
-    }>>;
-    readonly refute: import("@elaraai/east").OptionType<StructType<{
-        readonly placebo: BooleanType;
-        readonly random_common_cause: BooleanType;
-        readonly data_subset: BooleanType;
-        readonly sensitivity: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-    }>>;
-    readonly dose_feature: import("@elaraai/east").OptionType<StringType>;
-    readonly min_overlap: import("@elaraai/east").OptionType<FloatType>;
-    readonly min_treatment_variation: import("@elaraai/east").OptionType<FloatType>;
-    readonly bootstrap: import("@elaraai/east").OptionType<StructType<{
-        readonly reps: IntegerType;
-        readonly cluster_column: import("@elaraai/east").OptionType<StringType>;
-        readonly confidence_level: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
-    readonly strong_overlap: import("@elaraai/east").OptionType<FloatType>;
-    readonly evalue_floor: import("@elaraai/east").OptionType<FloatType>;
-    readonly expected_sign: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly positive: import("@elaraai/east").NullType;
-        readonly negative: import("@elaraai/east").NullType;
-    }>>;
-}>], StructType<{
-    readonly naive: FloatType;
-    readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
-        readonly lower: FloatType;
-        readonly upper: FloatType;
-    }>>;
-    readonly adjusted: import("@elaraai/east").OptionType<StructType<{
-        readonly effect: FloatType;
-        readonly ci: import("@elaraai/east").OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-    }>>;
-    readonly n_total: IntegerType;
-    readonly n_treated: IntegerType;
-    readonly n_control: IntegerType;
-    readonly n_dropped: IntegerType;
-    readonly balance: ArrayType<StructType<{
-        readonly column: StringType;
-        readonly base_column: StringType;
-        readonly treated_mean: FloatType;
-        readonly control_mean: FloatType;
-        readonly std_diff: FloatType;
-        readonly std_diff_adjusted: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly overlap: StructType<{
-        readonly treated_propensity: import("@elaraai/east").VectorType<FloatType>;
-        readonly control_propensity: import("@elaraai/east").VectorType<FloatType>;
-        readonly common_support_frac: FloatType;
-        readonly positivity_ok: BooleanType;
-        readonly support_strength: import("@elaraai/east").VariantType<{
-            readonly refused: import("@elaraai/east").NullType;
-            readonly thin: import("@elaraai/east").NullType;
-            readonly strong: import("@elaraai/east").NullType;
-        }>;
-    }>;
-    readonly refutation: import("@elaraai/east").OptionType<StructType<{
-        readonly placebo_effect: import("@elaraai/east").OptionType<FloatType>;
-        readonly placebo_passes: import("@elaraai/east").OptionType<BooleanType>;
-        readonly random_cc_within_ci: import("@elaraai/east").OptionType<BooleanType>;
-        readonly data_subset_effect: import("@elaraai/east").OptionType<FloatType>;
-        readonly data_subset_std: import("@elaraai/east").OptionType<FloatType>;
-        readonly robustness_value: import("@elaraai/east").OptionType<FloatType>;
-        readonly sensitivity: import("@elaraai/east").OptionType<StructType<{
-            readonly strengths: import("@elaraai/east").VectorType<FloatType>;
-            readonly effects: import("@elaraai/east").VectorType<FloatType>;
-            readonly benchmarks: ArrayType<StructType<{
-                readonly column: StringType;
-                readonly strength: FloatType;
-            }>>;
-        }>>;
-        readonly expected_sign_ok: import("@elaraai/east").OptionType<BooleanType>;
-    }>>;
-    readonly dose_response: import("@elaraai/east").OptionType<StructType<{
-        readonly feature: StringType;
-        readonly grid: import("@elaraai/east").VectorType<FloatType>;
-        readonly effect: import("@elaraai/east").VectorType<FloatType>;
-        readonly lower: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-        readonly upper: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-        readonly size: import("@elaraai/east").VectorType<IntegerType>;
-    }>>;
-    readonly verdict: import("@elaraai/east").VariantType<{
-        readonly causal: import("@elaraai/east").NullType;
-        readonly modest: import("@elaraai/east").NullType;
-        readonly adjustment_insufficient: import("@elaraai/east").NullType;
-        readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-        readonly not_estimable: StringType;
-    }>;
-    readonly verdict_reasons: ArrayType<import("@elaraai/east").VariantType<{
-        readonly placebo_failed: import("@elaraai/east").NullType;
-        readonly not_material: import("@elaraai/east").NullType;
-        readonly ci_spans_zero: import("@elaraai/east").NullType;
-        readonly wrong_sign: import("@elaraai/east").NullType;
-        readonly thin_support: import("@elaraai/east").NullType;
-        readonly low_robustness: import("@elaraai/east").NullType;
-    }>>;
-    readonly outcome_sd: FloatType;
-    readonly materiality_threshold: FloatType;
-    readonly treated_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-    readonly control_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-}>>;
-export declare const designFn: import("@elaraai/e3").FunctionDef<[ArrayType<StructType<{
-    readonly slow_cure: BooleanType;
-    readonly bond_strength: FloatType;
-    readonly incoming_grade: FloatType;
-    readonly mix_viscosity: FloatType;
-    readonly supplier: IntegerType;
-    readonly line: StringType;
-    readonly product: StringType;
-    readonly run_date: DateTimeType;
-}>>, StructType<{
-    readonly treatment: StringType;
-    readonly outcome: StringType;
-    readonly common_causes: ArrayType<StringType>;
-    readonly categorical: import("@elaraai/east").OptionType<ArrayType<StringType>>;
-    readonly method: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly linear_regression: import("@elaraai/east").NullType;
-        readonly propensity_score_weighting: StructType<{
-            readonly weighting_scheme: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                readonly ips_weight: import("@elaraai/east").NullType;
-                readonly ips_stabilized_weight: import("@elaraai/east").NullType;
-                readonly ips_normalized_weight: import("@elaraai/east").NullType;
-            }>>;
-        }>;
-    }>>;
-    readonly estimand: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly ate: import("@elaraai/east").NullType;
-        readonly att: import("@elaraai/east").NullType;
-        readonly atc: import("@elaraai/east").NullType;
-    }>>;
-    readonly refute: import("@elaraai/east").OptionType<StructType<{
-        readonly placebo: BooleanType;
-        readonly random_common_cause: BooleanType;
-        readonly data_subset: BooleanType;
-        readonly sensitivity: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-    }>>;
-    readonly dose_feature: import("@elaraai/east").OptionType<StringType>;
-    readonly min_overlap: import("@elaraai/east").OptionType<FloatType>;
-    readonly min_treatment_variation: import("@elaraai/east").OptionType<FloatType>;
-    readonly bootstrap: import("@elaraai/east").OptionType<StructType<{
-        readonly reps: IntegerType;
-        readonly cluster_column: import("@elaraai/east").OptionType<StringType>;
-        readonly confidence_level: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
-    readonly strong_overlap: import("@elaraai/east").OptionType<FloatType>;
-    readonly evalue_floor: import("@elaraai/east").OptionType<FloatType>;
-    readonly expected_sign: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly positive: import("@elaraai/east").NullType;
-        readonly negative: import("@elaraai/east").NullType;
-    }>>;
-}>, StructType<{
-    readonly naive: FloatType;
-    readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
-        readonly lower: FloatType;
-        readonly upper: FloatType;
-    }>>;
-    readonly adjusted: import("@elaraai/east").OptionType<StructType<{
-        readonly effect: FloatType;
-        readonly ci: import("@elaraai/east").OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-    }>>;
-    readonly n_total: IntegerType;
-    readonly n_treated: IntegerType;
-    readonly n_control: IntegerType;
-    readonly n_dropped: IntegerType;
-    readonly balance: ArrayType<StructType<{
-        readonly column: StringType;
-        readonly base_column: StringType;
-        readonly treated_mean: FloatType;
-        readonly control_mean: FloatType;
-        readonly std_diff: FloatType;
-        readonly std_diff_adjusted: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly overlap: StructType<{
-        readonly treated_propensity: import("@elaraai/east").VectorType<FloatType>;
-        readonly control_propensity: import("@elaraai/east").VectorType<FloatType>;
-        readonly common_support_frac: FloatType;
-        readonly positivity_ok: BooleanType;
-        readonly support_strength: import("@elaraai/east").VariantType<{
-            readonly refused: import("@elaraai/east").NullType;
-            readonly thin: import("@elaraai/east").NullType;
-            readonly strong: import("@elaraai/east").NullType;
-        }>;
-    }>;
-    readonly refutation: import("@elaraai/east").OptionType<StructType<{
-        readonly placebo_effect: import("@elaraai/east").OptionType<FloatType>;
-        readonly placebo_passes: import("@elaraai/east").OptionType<BooleanType>;
-        readonly random_cc_within_ci: import("@elaraai/east").OptionType<BooleanType>;
-        readonly data_subset_effect: import("@elaraai/east").OptionType<FloatType>;
-        readonly data_subset_std: import("@elaraai/east").OptionType<FloatType>;
-        readonly robustness_value: import("@elaraai/east").OptionType<FloatType>;
-        readonly sensitivity: import("@elaraai/east").OptionType<StructType<{
-            readonly strengths: import("@elaraai/east").VectorType<FloatType>;
-            readonly effects: import("@elaraai/east").VectorType<FloatType>;
-            readonly benchmarks: ArrayType<StructType<{
-                readonly column: StringType;
-                readonly strength: FloatType;
-            }>>;
-        }>>;
-        readonly expected_sign_ok: import("@elaraai/east").OptionType<BooleanType>;
-    }>>;
-    readonly dose_response: import("@elaraai/east").OptionType<StructType<{
-        readonly feature: StringType;
-        readonly grid: import("@elaraai/east").VectorType<FloatType>;
-        readonly effect: import("@elaraai/east").VectorType<FloatType>;
-        readonly lower: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-        readonly upper: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-        readonly size: import("@elaraai/east").VectorType<IntegerType>;
-    }>>;
-    readonly verdict: import("@elaraai/east").VariantType<{
-        readonly causal: import("@elaraai/east").NullType;
-        readonly modest: import("@elaraai/east").NullType;
-        readonly adjustment_insufficient: import("@elaraai/east").NullType;
-        readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-        readonly not_estimable: StringType;
-    }>;
-    readonly verdict_reasons: ArrayType<import("@elaraai/east").VariantType<{
-        readonly placebo_failed: import("@elaraai/east").NullType;
-        readonly not_material: import("@elaraai/east").NullType;
-        readonly ci_spans_zero: import("@elaraai/east").NullType;
-        readonly wrong_sign: import("@elaraai/east").NullType;
-        readonly thin_support: import("@elaraai/east").NullType;
-        readonly low_robustness: import("@elaraai/east").NullType;
-    }>>;
-    readonly outcome_sd: FloatType;
-    readonly materiality_threshold: FloatType;
-    readonly treated_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-    readonly control_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-}>, StructType<{
-    readonly alpha: import("@elaraai/east").OptionType<FloatType>;
-    readonly target_power: import("@elaraai/east").OptionType<FloatType>;
-    readonly materiality: import("@elaraai/east").OptionType<FloatType>;
-    readonly treated_shares: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-}>], StructType<{
-    readonly verdict: import("@elaraai/east").VariantType<{
-        readonly causal: import("@elaraai/east").NullType;
-        readonly modest: import("@elaraai/east").NullType;
-        readonly adjustment_insufficient: import("@elaraai/east").NullType;
-        readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-        readonly not_estimable: StringType;
-    }>;
-    readonly basis: import("@elaraai/east").VariantType<{
-        readonly detect_observed: import("@elaraai/east").NullType;
-        readonly resolve_vs_null: import("@elaraai/east").NullType;
-        readonly de_bias: import("@elaraai/east").NullType;
-        readonly restrict_to_overlap: import("@elaraai/east").NullType;
-        readonly create_control: import("@elaraai/east").NullType;
-    }>;
-    readonly target_effect: FloatType;
-    readonly outcome_sd: FloatType;
-    readonly target_power: FloatType;
-    readonly alpha: FloatType;
-    readonly current_power: import("@elaraai/east").OptionType<FloatType>;
-    readonly match_on: ArrayType<StringType>;
-    readonly options: ArrayType<StructType<{
-        readonly label: StringType;
-        readonly treated_share: FloatType;
-        readonly n_treated: IntegerType;
-        readonly n_control: IntegerType;
-        readonly n_total: IntegerType;
-    }>>;
-    readonly power_curve: StructType<{
-        readonly n: import("@elaraai/east").VectorType<IntegerType>;
-        readonly power: import("@elaraai/east").VectorType<FloatType>;
-    }>;
-    readonly rationale: StringType;
-}>>;
-/** A single question, no precomputed answer — the estimator auto-runs on select. */
-export declare const experimentConfigsInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly id: StringType;
-    readonly label: StringType;
-    readonly spec: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: import("@elaraai/east").OptionType<ArrayType<StringType>>;
-        readonly method: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly linear_regression: import("@elaraai/east").NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly ips_weight: import("@elaraai/east").NullType;
-                    readonly ips_stabilized_weight: import("@elaraai/east").NullType;
-                    readonly ips_normalized_weight: import("@elaraai/east").NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly ate: import("@elaraai/east").NullType;
-            readonly att: import("@elaraai/east").NullType;
-            readonly atc: import("@elaraai/east").NullType;
-        }>>;
-        readonly refute: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo: BooleanType;
-            readonly random_common_cause: BooleanType;
-            readonly data_subset: BooleanType;
-            readonly sensitivity: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-        }>>;
-        readonly dose_feature: import("@elaraai/east").OptionType<StringType>;
-        readonly min_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly min_treatment_variation: import("@elaraai/east").OptionType<FloatType>;
-        readonly bootstrap: import("@elaraai/east").OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: import("@elaraai/east").OptionType<StringType>;
-            readonly confidence_level: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
-        readonly strong_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly evalue_floor: import("@elaraai/east").OptionType<FloatType>;
-        readonly expected_sign: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly positive: import("@elaraai/east").NullType;
-            readonly negative: import("@elaraai/east").NullType;
-        }>>;
-    }>;
-    readonly population: import("@elaraai/east").OptionType<ArrayType<import("@elaraai/east").VariantType<{
-        readonly string: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").StringType;
-                readonly neq: import("@elaraai/east").StringType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly contains: import("@elaraai/east").StringType;
-                readonly matches: import("@elaraai/east").StringType;
-                readonly startsWith: import("@elaraai/east").StringType;
-                readonly endsWith: import("@elaraai/east").StringType;
-                readonly isEmpty: import("@elaraai/east").NullType;
-                readonly isNotEmpty: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly integer: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").IntegerType;
-                readonly neq: import("@elaraai/east").IntegerType;
-                readonly lt: import("@elaraai/east").IntegerType;
-                readonly lte: import("@elaraai/east").IntegerType;
-                readonly gt: import("@elaraai/east").IntegerType;
-                readonly gte: import("@elaraai/east").IntegerType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-            }>;
-        }>;
-        readonly float: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly lt: import("@elaraai/east").FloatType;
-                readonly lte: import("@elaraai/east").FloatType;
-                readonly gt: import("@elaraai/east").FloatType;
-                readonly gte: import("@elaraai/east").FloatType;
-            }>;
-        }>;
-        readonly datetime: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly before: import("@elaraai/east").DateTimeType;
-                readonly after: import("@elaraai/east").DateTimeType;
-                readonly between: import("@elaraai/east").StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-            }>;
-        }>;
-        readonly boolean: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly is: import("@elaraai/east").BooleanType;
-            }>;
-        }>;
-    }>>>;
-    readonly group: import("@elaraai/east").OptionType<StringType>;
-    readonly result: import("@elaraai/east").OptionType<StructType<{
-        readonly naive: FloatType;
-        readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-        readonly adjusted: import("@elaraai/east").OptionType<StructType<{
-            readonly effect: FloatType;
-            readonly ci: import("@elaraai/east").OptionType<StructType<{
-                readonly lower: FloatType;
-                readonly upper: FloatType;
-            }>>;
-        }>>;
-        readonly n_total: IntegerType;
-        readonly n_treated: IntegerType;
-        readonly n_control: IntegerType;
-        readonly n_dropped: IntegerType;
-        readonly balance: ArrayType<StructType<{
-            readonly column: StringType;
-            readonly base_column: StringType;
-            readonly treated_mean: FloatType;
-            readonly control_mean: FloatType;
-            readonly std_diff: FloatType;
-            readonly std_diff_adjusted: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly overlap: StructType<{
-            readonly treated_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly control_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly common_support_frac: FloatType;
-            readonly positivity_ok: BooleanType;
-            readonly support_strength: import("@elaraai/east").VariantType<{
-                readonly refused: import("@elaraai/east").NullType;
-                readonly thin: import("@elaraai/east").NullType;
-                readonly strong: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly refutation: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly placebo_passes: import("@elaraai/east").OptionType<BooleanType>;
-            readonly random_cc_within_ci: import("@elaraai/east").OptionType<BooleanType>;
-            readonly data_subset_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly data_subset_std: import("@elaraai/east").OptionType<FloatType>;
-            readonly robustness_value: import("@elaraai/east").OptionType<FloatType>;
-            readonly sensitivity: import("@elaraai/east").OptionType<StructType<{
-                readonly strengths: import("@elaraai/east").VectorType<FloatType>;
-                readonly effects: import("@elaraai/east").VectorType<FloatType>;
-                readonly benchmarks: ArrayType<StructType<{
-                    readonly column: StringType;
-                    readonly strength: FloatType;
-                }>>;
-            }>>;
-            readonly expected_sign_ok: import("@elaraai/east").OptionType<BooleanType>;
-        }>>;
-        readonly dose_response: import("@elaraai/east").OptionType<StructType<{
-            readonly feature: StringType;
-            readonly grid: import("@elaraai/east").VectorType<FloatType>;
-            readonly effect: import("@elaraai/east").VectorType<FloatType>;
-            readonly lower: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly upper: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly size: import("@elaraai/east").VectorType<IntegerType>;
-        }>>;
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly verdict_reasons: ArrayType<import("@elaraai/east").VariantType<{
-            readonly placebo_failed: import("@elaraai/east").NullType;
-            readonly not_material: import("@elaraai/east").NullType;
-            readonly ci_spans_zero: import("@elaraai/east").NullType;
-            readonly wrong_sign: import("@elaraai/east").NullType;
-            readonly thin_support: import("@elaraai/east").NullType;
-            readonly low_robustness: import("@elaraai/east").NullType;
-        }>>;
-        readonly outcome_sd: FloatType;
-        readonly materiality_threshold: FloatType;
-        readonly treated_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-        readonly control_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly design: import("@elaraai/east").OptionType<StructType<{
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly basis: import("@elaraai/east").VariantType<{
-            readonly detect_observed: import("@elaraai/east").NullType;
-            readonly resolve_vs_null: import("@elaraai/east").NullType;
-            readonly de_bias: import("@elaraai/east").NullType;
-            readonly restrict_to_overlap: import("@elaraai/east").NullType;
-            readonly create_control: import("@elaraai/east").NullType;
-        }>;
-        readonly target_effect: FloatType;
-        readonly outcome_sd: FloatType;
-        readonly target_power: FloatType;
-        readonly alpha: FloatType;
-        readonly current_power: import("@elaraai/east").OptionType<FloatType>;
-        readonly match_on: ArrayType<StringType>;
-        readonly options: ArrayType<StructType<{
-            readonly label: StringType;
-            readonly treated_share: FloatType;
-            readonly n_treated: IntegerType;
-            readonly n_control: IntegerType;
-            readonly n_total: IntegerType;
-        }>>;
-        readonly power_curve: StructType<{
-            readonly n: import("@elaraai/east").VectorType<IntegerType>;
-            readonly power: import("@elaraai/east").VectorType<FloatType>;
-        }>;
-        readonly rationale: StringType;
-    }>>;
-}>>, [variant<"field", "inputs">, variant<"field", "experiment_configs">]>;
-/** Three vetted questions — the curated menu (no precomputed answers; each runs live). */
-export declare const experimentMenuConfigsInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly id: StringType;
-    readonly label: StringType;
-    readonly spec: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: import("@elaraai/east").OptionType<ArrayType<StringType>>;
-        readonly method: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly linear_regression: import("@elaraai/east").NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly ips_weight: import("@elaraai/east").NullType;
-                    readonly ips_stabilized_weight: import("@elaraai/east").NullType;
-                    readonly ips_normalized_weight: import("@elaraai/east").NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly ate: import("@elaraai/east").NullType;
-            readonly att: import("@elaraai/east").NullType;
-            readonly atc: import("@elaraai/east").NullType;
-        }>>;
-        readonly refute: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo: BooleanType;
-            readonly random_common_cause: BooleanType;
-            readonly data_subset: BooleanType;
-            readonly sensitivity: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-        }>>;
-        readonly dose_feature: import("@elaraai/east").OptionType<StringType>;
-        readonly min_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly min_treatment_variation: import("@elaraai/east").OptionType<FloatType>;
-        readonly bootstrap: import("@elaraai/east").OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: import("@elaraai/east").OptionType<StringType>;
-            readonly confidence_level: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
-        readonly strong_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly evalue_floor: import("@elaraai/east").OptionType<FloatType>;
-        readonly expected_sign: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly positive: import("@elaraai/east").NullType;
-            readonly negative: import("@elaraai/east").NullType;
-        }>>;
-    }>;
-    readonly population: import("@elaraai/east").OptionType<ArrayType<import("@elaraai/east").VariantType<{
-        readonly string: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").StringType;
-                readonly neq: import("@elaraai/east").StringType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly contains: import("@elaraai/east").StringType;
-                readonly matches: import("@elaraai/east").StringType;
-                readonly startsWith: import("@elaraai/east").StringType;
-                readonly endsWith: import("@elaraai/east").StringType;
-                readonly isEmpty: import("@elaraai/east").NullType;
-                readonly isNotEmpty: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly integer: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").IntegerType;
-                readonly neq: import("@elaraai/east").IntegerType;
-                readonly lt: import("@elaraai/east").IntegerType;
-                readonly lte: import("@elaraai/east").IntegerType;
-                readonly gt: import("@elaraai/east").IntegerType;
-                readonly gte: import("@elaraai/east").IntegerType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-            }>;
-        }>;
-        readonly float: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly lt: import("@elaraai/east").FloatType;
-                readonly lte: import("@elaraai/east").FloatType;
-                readonly gt: import("@elaraai/east").FloatType;
-                readonly gte: import("@elaraai/east").FloatType;
-            }>;
-        }>;
-        readonly datetime: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly before: import("@elaraai/east").DateTimeType;
-                readonly after: import("@elaraai/east").DateTimeType;
-                readonly between: import("@elaraai/east").StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-            }>;
-        }>;
-        readonly boolean: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly is: import("@elaraai/east").BooleanType;
-            }>;
-        }>;
-    }>>>;
-    readonly group: import("@elaraai/east").OptionType<StringType>;
-    readonly result: import("@elaraai/east").OptionType<StructType<{
-        readonly naive: FloatType;
-        readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-        readonly adjusted: import("@elaraai/east").OptionType<StructType<{
-            readonly effect: FloatType;
-            readonly ci: import("@elaraai/east").OptionType<StructType<{
-                readonly lower: FloatType;
-                readonly upper: FloatType;
-            }>>;
-        }>>;
-        readonly n_total: IntegerType;
-        readonly n_treated: IntegerType;
-        readonly n_control: IntegerType;
-        readonly n_dropped: IntegerType;
-        readonly balance: ArrayType<StructType<{
-            readonly column: StringType;
-            readonly base_column: StringType;
-            readonly treated_mean: FloatType;
-            readonly control_mean: FloatType;
-            readonly std_diff: FloatType;
-            readonly std_diff_adjusted: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly overlap: StructType<{
-            readonly treated_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly control_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly common_support_frac: FloatType;
-            readonly positivity_ok: BooleanType;
-            readonly support_strength: import("@elaraai/east").VariantType<{
-                readonly refused: import("@elaraai/east").NullType;
-                readonly thin: import("@elaraai/east").NullType;
-                readonly strong: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly refutation: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly placebo_passes: import("@elaraai/east").OptionType<BooleanType>;
-            readonly random_cc_within_ci: import("@elaraai/east").OptionType<BooleanType>;
-            readonly data_subset_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly data_subset_std: import("@elaraai/east").OptionType<FloatType>;
-            readonly robustness_value: import("@elaraai/east").OptionType<FloatType>;
-            readonly sensitivity: import("@elaraai/east").OptionType<StructType<{
-                readonly strengths: import("@elaraai/east").VectorType<FloatType>;
-                readonly effects: import("@elaraai/east").VectorType<FloatType>;
-                readonly benchmarks: ArrayType<StructType<{
-                    readonly column: StringType;
-                    readonly strength: FloatType;
-                }>>;
-            }>>;
-            readonly expected_sign_ok: import("@elaraai/east").OptionType<BooleanType>;
-        }>>;
-        readonly dose_response: import("@elaraai/east").OptionType<StructType<{
-            readonly feature: StringType;
-            readonly grid: import("@elaraai/east").VectorType<FloatType>;
-            readonly effect: import("@elaraai/east").VectorType<FloatType>;
-            readonly lower: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly upper: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly size: import("@elaraai/east").VectorType<IntegerType>;
-        }>>;
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly verdict_reasons: ArrayType<import("@elaraai/east").VariantType<{
-            readonly placebo_failed: import("@elaraai/east").NullType;
-            readonly not_material: import("@elaraai/east").NullType;
-            readonly ci_spans_zero: import("@elaraai/east").NullType;
-            readonly wrong_sign: import("@elaraai/east").NullType;
-            readonly thin_support: import("@elaraai/east").NullType;
-            readonly low_robustness: import("@elaraai/east").NullType;
-        }>>;
-        readonly outcome_sd: FloatType;
-        readonly materiality_threshold: FloatType;
-        readonly treated_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-        readonly control_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly design: import("@elaraai/east").OptionType<StructType<{
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly basis: import("@elaraai/east").VariantType<{
-            readonly detect_observed: import("@elaraai/east").NullType;
-            readonly resolve_vs_null: import("@elaraai/east").NullType;
-            readonly de_bias: import("@elaraai/east").NullType;
-            readonly restrict_to_overlap: import("@elaraai/east").NullType;
-            readonly create_control: import("@elaraai/east").NullType;
-        }>;
-        readonly target_effect: FloatType;
-        readonly outcome_sd: FloatType;
-        readonly target_power: FloatType;
-        readonly alpha: FloatType;
-        readonly current_power: import("@elaraai/east").OptionType<FloatType>;
-        readonly match_on: ArrayType<StringType>;
-        readonly options: ArrayType<StructType<{
-            readonly label: StringType;
-            readonly treated_share: FloatType;
-            readonly n_treated: IntegerType;
-            readonly n_control: IntegerType;
-            readonly n_total: IntegerType;
-        }>>;
-        readonly power_curve: StructType<{
-            readonly n: import("@elaraai/east").VectorType<IntegerType>;
-            readonly power: import("@elaraai/east").VectorType<FloatType>;
-        }>;
-        readonly rationale: StringType;
-    }>>;
-}>>, [variant<"field", "inputs">, variant<"field", "experiment_menu_configs">]>;
-/** Curated, precomputed — the question carries its answer inline; no estimator needed. */
-export declare const experimentPrecomputedConfigsInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly id: StringType;
-    readonly label: StringType;
-    readonly spec: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: import("@elaraai/east").OptionType<ArrayType<StringType>>;
-        readonly method: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly linear_regression: import("@elaraai/east").NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly ips_weight: import("@elaraai/east").NullType;
-                    readonly ips_stabilized_weight: import("@elaraai/east").NullType;
-                    readonly ips_normalized_weight: import("@elaraai/east").NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly ate: import("@elaraai/east").NullType;
-            readonly att: import("@elaraai/east").NullType;
-            readonly atc: import("@elaraai/east").NullType;
-        }>>;
-        readonly refute: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo: BooleanType;
-            readonly random_common_cause: BooleanType;
-            readonly data_subset: BooleanType;
-            readonly sensitivity: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-        }>>;
-        readonly dose_feature: import("@elaraai/east").OptionType<StringType>;
-        readonly min_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly min_treatment_variation: import("@elaraai/east").OptionType<FloatType>;
-        readonly bootstrap: import("@elaraai/east").OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: import("@elaraai/east").OptionType<StringType>;
-            readonly confidence_level: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
-        readonly strong_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly evalue_floor: import("@elaraai/east").OptionType<FloatType>;
-        readonly expected_sign: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly positive: import("@elaraai/east").NullType;
-            readonly negative: import("@elaraai/east").NullType;
-        }>>;
-    }>;
-    readonly population: import("@elaraai/east").OptionType<ArrayType<import("@elaraai/east").VariantType<{
-        readonly string: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").StringType;
-                readonly neq: import("@elaraai/east").StringType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly contains: import("@elaraai/east").StringType;
-                readonly matches: import("@elaraai/east").StringType;
-                readonly startsWith: import("@elaraai/east").StringType;
-                readonly endsWith: import("@elaraai/east").StringType;
-                readonly isEmpty: import("@elaraai/east").NullType;
-                readonly isNotEmpty: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly integer: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").IntegerType;
-                readonly neq: import("@elaraai/east").IntegerType;
-                readonly lt: import("@elaraai/east").IntegerType;
-                readonly lte: import("@elaraai/east").IntegerType;
-                readonly gt: import("@elaraai/east").IntegerType;
-                readonly gte: import("@elaraai/east").IntegerType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-            }>;
-        }>;
-        readonly float: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly lt: import("@elaraai/east").FloatType;
-                readonly lte: import("@elaraai/east").FloatType;
-                readonly gt: import("@elaraai/east").FloatType;
-                readonly gte: import("@elaraai/east").FloatType;
-            }>;
-        }>;
-        readonly datetime: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly before: import("@elaraai/east").DateTimeType;
-                readonly after: import("@elaraai/east").DateTimeType;
-                readonly between: import("@elaraai/east").StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-            }>;
-        }>;
-        readonly boolean: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly is: import("@elaraai/east").BooleanType;
-            }>;
-        }>;
-    }>>>;
-    readonly group: import("@elaraai/east").OptionType<StringType>;
-    readonly result: import("@elaraai/east").OptionType<StructType<{
-        readonly naive: FloatType;
-        readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-        readonly adjusted: import("@elaraai/east").OptionType<StructType<{
-            readonly effect: FloatType;
-            readonly ci: import("@elaraai/east").OptionType<StructType<{
-                readonly lower: FloatType;
-                readonly upper: FloatType;
-            }>>;
-        }>>;
-        readonly n_total: IntegerType;
-        readonly n_treated: IntegerType;
-        readonly n_control: IntegerType;
-        readonly n_dropped: IntegerType;
-        readonly balance: ArrayType<StructType<{
-            readonly column: StringType;
-            readonly base_column: StringType;
-            readonly treated_mean: FloatType;
-            readonly control_mean: FloatType;
-            readonly std_diff: FloatType;
-            readonly std_diff_adjusted: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly overlap: StructType<{
-            readonly treated_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly control_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly common_support_frac: FloatType;
-            readonly positivity_ok: BooleanType;
-            readonly support_strength: import("@elaraai/east").VariantType<{
-                readonly refused: import("@elaraai/east").NullType;
-                readonly thin: import("@elaraai/east").NullType;
-                readonly strong: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly refutation: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly placebo_passes: import("@elaraai/east").OptionType<BooleanType>;
-            readonly random_cc_within_ci: import("@elaraai/east").OptionType<BooleanType>;
-            readonly data_subset_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly data_subset_std: import("@elaraai/east").OptionType<FloatType>;
-            readonly robustness_value: import("@elaraai/east").OptionType<FloatType>;
-            readonly sensitivity: import("@elaraai/east").OptionType<StructType<{
-                readonly strengths: import("@elaraai/east").VectorType<FloatType>;
-                readonly effects: import("@elaraai/east").VectorType<FloatType>;
-                readonly benchmarks: ArrayType<StructType<{
-                    readonly column: StringType;
-                    readonly strength: FloatType;
-                }>>;
-            }>>;
-            readonly expected_sign_ok: import("@elaraai/east").OptionType<BooleanType>;
-        }>>;
-        readonly dose_response: import("@elaraai/east").OptionType<StructType<{
-            readonly feature: StringType;
-            readonly grid: import("@elaraai/east").VectorType<FloatType>;
-            readonly effect: import("@elaraai/east").VectorType<FloatType>;
-            readonly lower: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly upper: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly size: import("@elaraai/east").VectorType<IntegerType>;
-        }>>;
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly verdict_reasons: ArrayType<import("@elaraai/east").VariantType<{
-            readonly placebo_failed: import("@elaraai/east").NullType;
-            readonly not_material: import("@elaraai/east").NullType;
-            readonly ci_spans_zero: import("@elaraai/east").NullType;
-            readonly wrong_sign: import("@elaraai/east").NullType;
-            readonly thin_support: import("@elaraai/east").NullType;
-            readonly low_robustness: import("@elaraai/east").NullType;
-        }>>;
-        readonly outcome_sd: FloatType;
-        readonly materiality_threshold: FloatType;
-        readonly treated_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-        readonly control_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly design: import("@elaraai/east").OptionType<StructType<{
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly basis: import("@elaraai/east").VariantType<{
-            readonly detect_observed: import("@elaraai/east").NullType;
-            readonly resolve_vs_null: import("@elaraai/east").NullType;
-            readonly de_bias: import("@elaraai/east").NullType;
-            readonly restrict_to_overlap: import("@elaraai/east").NullType;
-            readonly create_control: import("@elaraai/east").NullType;
-        }>;
-        readonly target_effect: FloatType;
-        readonly outcome_sd: FloatType;
-        readonly target_power: FloatType;
-        readonly alpha: FloatType;
-        readonly current_power: import("@elaraai/east").OptionType<FloatType>;
-        readonly match_on: ArrayType<StringType>;
-        readonly options: ArrayType<StructType<{
-            readonly label: StringType;
-            readonly treated_share: FloatType;
-            readonly n_treated: IntegerType;
-            readonly n_control: IntegerType;
-            readonly n_total: IntegerType;
-        }>>;
-        readonly power_curve: StructType<{
-            readonly n: import("@elaraai/east").VectorType<IntegerType>;
-            readonly power: import("@elaraai/east").VectorType<FloatType>;
-        }>;
-        readonly rationale: StringType;
-    }>>;
-}>>, [variant<"field", "inputs">, variant<"field", "experiment_precomputed_configs">]>;
-export declare const experimentJournalInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly config: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: import("@elaraai/east").OptionType<ArrayType<StringType>>;
-        readonly method: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly linear_regression: import("@elaraai/east").NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly ips_weight: import("@elaraai/east").NullType;
-                    readonly ips_stabilized_weight: import("@elaraai/east").NullType;
-                    readonly ips_normalized_weight: import("@elaraai/east").NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly ate: import("@elaraai/east").NullType;
-            readonly att: import("@elaraai/east").NullType;
-            readonly atc: import("@elaraai/east").NullType;
-        }>>;
-        readonly refute: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo: BooleanType;
-            readonly random_common_cause: BooleanType;
-            readonly data_subset: BooleanType;
-            readonly sensitivity: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-        }>>;
-        readonly dose_feature: import("@elaraai/east").OptionType<StringType>;
-        readonly min_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly min_treatment_variation: import("@elaraai/east").OptionType<FloatType>;
-        readonly bootstrap: import("@elaraai/east").OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: import("@elaraai/east").OptionType<StringType>;
-            readonly confidence_level: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
-        readonly strong_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly evalue_floor: import("@elaraai/east").OptionType<FloatType>;
-        readonly expected_sign: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly positive: import("@elaraai/east").NullType;
-            readonly negative: import("@elaraai/east").NullType;
-        }>>;
-    }>;
-    readonly verdict: import("@elaraai/east").VariantType<{
-        readonly causal: import("@elaraai/east").NullType;
-        readonly modest: import("@elaraai/east").NullType;
-        readonly adjustment_insufficient: import("@elaraai/east").NullType;
-        readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-        readonly not_estimable: StringType;
-    }>;
-    readonly naive: FloatType;
-    readonly adjusted: import("@elaraai/east").OptionType<FloatType>;
-    readonly committed_at: DateTimeType;
-    readonly committed_by: StringType;
-    readonly preset: import("@elaraai/east").OptionType<StringType>;
-}>>, [variant<"field", "inputs">, variant<"field", "experiment_journal">]>;
-/** Freeform single-question surface — one config, the estimator auto-runs. */
-export declare const experimentSurface: import("@elaraai/east").ExampleDef<[], any>;
-export declare const experimentTrust: import("@elaraai/east").ExampleDef<[], any>;
-export declare const experimentDose: import("@elaraai/east").ExampleDef<[], any>;
-export declare const experimentValidate: import("@elaraai/east").ExampleDef<[], any>;
-/** The question selector — a menu of three vetted questions, each estimated live. */
-export declare const experimentMenu: import("@elaraai/east").ExampleDef<[], any>;
-/** Curated decision surface — a precomputed answer (browsable and locked), no live estimator. */
-export declare const experimentPrecomputed: import("@elaraai/east").ExampleDef<[], any>;
-export declare const experimentPositivityConfigsInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly id: StringType;
-    readonly label: StringType;
-    readonly spec: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: import("@elaraai/east").OptionType<ArrayType<StringType>>;
-        readonly method: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly linear_regression: import("@elaraai/east").NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly ips_weight: import("@elaraai/east").NullType;
-                    readonly ips_stabilized_weight: import("@elaraai/east").NullType;
-                    readonly ips_normalized_weight: import("@elaraai/east").NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly ate: import("@elaraai/east").NullType;
-            readonly att: import("@elaraai/east").NullType;
-            readonly atc: import("@elaraai/east").NullType;
-        }>>;
-        readonly refute: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo: BooleanType;
-            readonly random_common_cause: BooleanType;
-            readonly data_subset: BooleanType;
-            readonly sensitivity: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-        }>>;
-        readonly dose_feature: import("@elaraai/east").OptionType<StringType>;
-        readonly min_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly min_treatment_variation: import("@elaraai/east").OptionType<FloatType>;
-        readonly bootstrap: import("@elaraai/east").OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: import("@elaraai/east").OptionType<StringType>;
-            readonly confidence_level: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
-        readonly strong_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly evalue_floor: import("@elaraai/east").OptionType<FloatType>;
-        readonly expected_sign: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly positive: import("@elaraai/east").NullType;
-            readonly negative: import("@elaraai/east").NullType;
-        }>>;
-    }>;
-    readonly population: import("@elaraai/east").OptionType<ArrayType<import("@elaraai/east").VariantType<{
-        readonly string: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").StringType;
-                readonly neq: import("@elaraai/east").StringType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly contains: import("@elaraai/east").StringType;
-                readonly matches: import("@elaraai/east").StringType;
-                readonly startsWith: import("@elaraai/east").StringType;
-                readonly endsWith: import("@elaraai/east").StringType;
-                readonly isEmpty: import("@elaraai/east").NullType;
-                readonly isNotEmpty: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly integer: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").IntegerType;
-                readonly neq: import("@elaraai/east").IntegerType;
-                readonly lt: import("@elaraai/east").IntegerType;
-                readonly lte: import("@elaraai/east").IntegerType;
-                readonly gt: import("@elaraai/east").IntegerType;
-                readonly gte: import("@elaraai/east").IntegerType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-            }>;
-        }>;
-        readonly float: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly lt: import("@elaraai/east").FloatType;
-                readonly lte: import("@elaraai/east").FloatType;
-                readonly gt: import("@elaraai/east").FloatType;
-                readonly gte: import("@elaraai/east").FloatType;
-            }>;
-        }>;
-        readonly datetime: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly before: import("@elaraai/east").DateTimeType;
-                readonly after: import("@elaraai/east").DateTimeType;
-                readonly between: import("@elaraai/east").StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-            }>;
-        }>;
-        readonly boolean: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly is: import("@elaraai/east").BooleanType;
-            }>;
-        }>;
-    }>>>;
-    readonly group: import("@elaraai/east").OptionType<StringType>;
-    readonly result: import("@elaraai/east").OptionType<StructType<{
-        readonly naive: FloatType;
-        readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-        readonly adjusted: import("@elaraai/east").OptionType<StructType<{
-            readonly effect: FloatType;
-            readonly ci: import("@elaraai/east").OptionType<StructType<{
-                readonly lower: FloatType;
-                readonly upper: FloatType;
-            }>>;
-        }>>;
-        readonly n_total: IntegerType;
-        readonly n_treated: IntegerType;
-        readonly n_control: IntegerType;
-        readonly n_dropped: IntegerType;
-        readonly balance: ArrayType<StructType<{
-            readonly column: StringType;
-            readonly base_column: StringType;
-            readonly treated_mean: FloatType;
-            readonly control_mean: FloatType;
-            readonly std_diff: FloatType;
-            readonly std_diff_adjusted: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly overlap: StructType<{
-            readonly treated_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly control_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly common_support_frac: FloatType;
-            readonly positivity_ok: BooleanType;
-            readonly support_strength: import("@elaraai/east").VariantType<{
-                readonly refused: import("@elaraai/east").NullType;
-                readonly thin: import("@elaraai/east").NullType;
-                readonly strong: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly refutation: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly placebo_passes: import("@elaraai/east").OptionType<BooleanType>;
-            readonly random_cc_within_ci: import("@elaraai/east").OptionType<BooleanType>;
-            readonly data_subset_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly data_subset_std: import("@elaraai/east").OptionType<FloatType>;
-            readonly robustness_value: import("@elaraai/east").OptionType<FloatType>;
-            readonly sensitivity: import("@elaraai/east").OptionType<StructType<{
-                readonly strengths: import("@elaraai/east").VectorType<FloatType>;
-                readonly effects: import("@elaraai/east").VectorType<FloatType>;
-                readonly benchmarks: ArrayType<StructType<{
-                    readonly column: StringType;
-                    readonly strength: FloatType;
-                }>>;
-            }>>;
-            readonly expected_sign_ok: import("@elaraai/east").OptionType<BooleanType>;
-        }>>;
-        readonly dose_response: import("@elaraai/east").OptionType<StructType<{
-            readonly feature: StringType;
-            readonly grid: import("@elaraai/east").VectorType<FloatType>;
-            readonly effect: import("@elaraai/east").VectorType<FloatType>;
-            readonly lower: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly upper: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly size: import("@elaraai/east").VectorType<IntegerType>;
-        }>>;
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly verdict_reasons: ArrayType<import("@elaraai/east").VariantType<{
-            readonly placebo_failed: import("@elaraai/east").NullType;
-            readonly not_material: import("@elaraai/east").NullType;
-            readonly ci_spans_zero: import("@elaraai/east").NullType;
-            readonly wrong_sign: import("@elaraai/east").NullType;
-            readonly thin_support: import("@elaraai/east").NullType;
-            readonly low_robustness: import("@elaraai/east").NullType;
-        }>>;
-        readonly outcome_sd: FloatType;
-        readonly materiality_threshold: FloatType;
-        readonly treated_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-        readonly control_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly design: import("@elaraai/east").OptionType<StructType<{
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly basis: import("@elaraai/east").VariantType<{
-            readonly detect_observed: import("@elaraai/east").NullType;
-            readonly resolve_vs_null: import("@elaraai/east").NullType;
-            readonly de_bias: import("@elaraai/east").NullType;
-            readonly restrict_to_overlap: import("@elaraai/east").NullType;
-            readonly create_control: import("@elaraai/east").NullType;
-        }>;
-        readonly target_effect: FloatType;
-        readonly outcome_sd: FloatType;
-        readonly target_power: FloatType;
-        readonly alpha: FloatType;
-        readonly current_power: import("@elaraai/east").OptionType<FloatType>;
-        readonly match_on: ArrayType<StringType>;
-        readonly options: ArrayType<StructType<{
-            readonly label: StringType;
-            readonly treated_share: FloatType;
-            readonly n_treated: IntegerType;
-            readonly n_control: IntegerType;
-            readonly n_total: IntegerType;
-        }>>;
-        readonly power_curve: StructType<{
-            readonly n: import("@elaraai/east").VectorType<IntegerType>;
-            readonly power: import("@elaraai/east").VectorType<FloatType>;
-        }>;
-        readonly rationale: StringType;
-    }>>;
-}>>, [variant<"field", "inputs">, variant<"field", "experiment_positivity_configs">]>;
-export declare const experimentNotEstimableConfigsInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly id: StringType;
-    readonly label: StringType;
-    readonly spec: StructType<{
-        readonly treatment: StringType;
-        readonly outcome: StringType;
-        readonly common_causes: ArrayType<StringType>;
-        readonly categorical: import("@elaraai/east").OptionType<ArrayType<StringType>>;
-        readonly method: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly linear_regression: import("@elaraai/east").NullType;
-            readonly propensity_score_weighting: StructType<{
-                readonly weighting_scheme: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-                    readonly ips_weight: import("@elaraai/east").NullType;
-                    readonly ips_stabilized_weight: import("@elaraai/east").NullType;
-                    readonly ips_normalized_weight: import("@elaraai/east").NullType;
-                }>>;
-            }>;
-        }>>;
-        readonly estimand: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly ate: import("@elaraai/east").NullType;
-            readonly att: import("@elaraai/east").NullType;
-            readonly atc: import("@elaraai/east").NullType;
-        }>>;
-        readonly refute: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo: BooleanType;
-            readonly random_common_cause: BooleanType;
-            readonly data_subset: BooleanType;
-            readonly sensitivity: import("@elaraai/east").OptionType<ArrayType<FloatType>>;
-        }>>;
-        readonly dose_feature: import("@elaraai/east").OptionType<StringType>;
-        readonly min_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly min_treatment_variation: import("@elaraai/east").OptionType<FloatType>;
-        readonly bootstrap: import("@elaraai/east").OptionType<StructType<{
-            readonly reps: IntegerType;
-            readonly cluster_column: import("@elaraai/east").OptionType<StringType>;
-            readonly confidence_level: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
-        readonly strong_overlap: import("@elaraai/east").OptionType<FloatType>;
-        readonly evalue_floor: import("@elaraai/east").OptionType<FloatType>;
-        readonly expected_sign: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly positive: import("@elaraai/east").NullType;
-            readonly negative: import("@elaraai/east").NullType;
-        }>>;
-    }>;
-    readonly population: import("@elaraai/east").OptionType<ArrayType<import("@elaraai/east").VariantType<{
-        readonly string: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").StringType;
-                readonly neq: import("@elaraai/east").StringType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly notIn: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
-                readonly contains: import("@elaraai/east").StringType;
-                readonly matches: import("@elaraai/east").StringType;
-                readonly startsWith: import("@elaraai/east").StringType;
-                readonly endsWith: import("@elaraai/east").StringType;
-                readonly isEmpty: import("@elaraai/east").NullType;
-                readonly isNotEmpty: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly integer: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly eq: import("@elaraai/east").IntegerType;
-                readonly neq: import("@elaraai/east").IntegerType;
-                readonly lt: import("@elaraai/east").IntegerType;
-                readonly lte: import("@elaraai/east").IntegerType;
-                readonly gt: import("@elaraai/east").IntegerType;
-                readonly gte: import("@elaraai/east").IntegerType;
-                readonly in: import("@elaraai/east").SetType<import("@elaraai/east").IntegerType>;
-            }>;
-        }>;
-        readonly float: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly lt: import("@elaraai/east").FloatType;
-                readonly lte: import("@elaraai/east").FloatType;
-                readonly gt: import("@elaraai/east").FloatType;
-                readonly gte: import("@elaraai/east").FloatType;
-            }>;
-        }>;
-        readonly datetime: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly before: import("@elaraai/east").DateTimeType;
-                readonly after: import("@elaraai/east").DateTimeType;
-                readonly between: import("@elaraai/east").StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-            }>;
-        }>;
-        readonly boolean: import("@elaraai/east").StructType<{
-            readonly fieldId: import("@elaraai/east").StringType;
-            readonly op: import("@elaraai/east").VariantType<{
-                readonly is: import("@elaraai/east").BooleanType;
-            }>;
-        }>;
-    }>>>;
-    readonly group: import("@elaraai/east").OptionType<StringType>;
-    readonly result: import("@elaraai/east").OptionType<StructType<{
-        readonly naive: FloatType;
-        readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>>;
-        readonly adjusted: import("@elaraai/east").OptionType<StructType<{
-            readonly effect: FloatType;
-            readonly ci: import("@elaraai/east").OptionType<StructType<{
-                readonly lower: FloatType;
-                readonly upper: FloatType;
-            }>>;
-        }>>;
-        readonly n_total: IntegerType;
-        readonly n_treated: IntegerType;
-        readonly n_control: IntegerType;
-        readonly n_dropped: IntegerType;
-        readonly balance: ArrayType<StructType<{
-            readonly column: StringType;
-            readonly base_column: StringType;
-            readonly treated_mean: FloatType;
-            readonly control_mean: FloatType;
-            readonly std_diff: FloatType;
-            readonly std_diff_adjusted: import("@elaraai/east").OptionType<FloatType>;
-        }>>;
-        readonly overlap: StructType<{
-            readonly treated_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly control_propensity: import("@elaraai/east").VectorType<FloatType>;
-            readonly common_support_frac: FloatType;
-            readonly positivity_ok: BooleanType;
-            readonly support_strength: import("@elaraai/east").VariantType<{
-                readonly refused: import("@elaraai/east").NullType;
-                readonly thin: import("@elaraai/east").NullType;
-                readonly strong: import("@elaraai/east").NullType;
-            }>;
-        }>;
-        readonly refutation: import("@elaraai/east").OptionType<StructType<{
-            readonly placebo_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly placebo_passes: import("@elaraai/east").OptionType<BooleanType>;
-            readonly random_cc_within_ci: import("@elaraai/east").OptionType<BooleanType>;
-            readonly data_subset_effect: import("@elaraai/east").OptionType<FloatType>;
-            readonly data_subset_std: import("@elaraai/east").OptionType<FloatType>;
-            readonly robustness_value: import("@elaraai/east").OptionType<FloatType>;
-            readonly sensitivity: import("@elaraai/east").OptionType<StructType<{
-                readonly strengths: import("@elaraai/east").VectorType<FloatType>;
-                readonly effects: import("@elaraai/east").VectorType<FloatType>;
-                readonly benchmarks: ArrayType<StructType<{
-                    readonly column: StringType;
-                    readonly strength: FloatType;
-                }>>;
-            }>>;
-            readonly expected_sign_ok: import("@elaraai/east").OptionType<BooleanType>;
-        }>>;
-        readonly dose_response: import("@elaraai/east").OptionType<StructType<{
-            readonly feature: StringType;
-            readonly grid: import("@elaraai/east").VectorType<FloatType>;
-            readonly effect: import("@elaraai/east").VectorType<FloatType>;
-            readonly lower: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly upper: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-            readonly size: import("@elaraai/east").VectorType<IntegerType>;
-        }>>;
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly verdict_reasons: ArrayType<import("@elaraai/east").VariantType<{
-            readonly placebo_failed: import("@elaraai/east").NullType;
-            readonly not_material: import("@elaraai/east").NullType;
-            readonly ci_spans_zero: import("@elaraai/east").NullType;
-            readonly wrong_sign: import("@elaraai/east").NullType;
-            readonly thin_support: import("@elaraai/east").NullType;
-            readonly low_robustness: import("@elaraai/east").NullType;
-        }>>;
-        readonly outcome_sd: FloatType;
-        readonly materiality_threshold: FloatType;
-        readonly treated_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-        readonly control_outcome_mean: import("@elaraai/east").OptionType<FloatType>;
-    }>>;
-    readonly design: import("@elaraai/east").OptionType<StructType<{
-        readonly verdict: import("@elaraai/east").VariantType<{
-            readonly causal: import("@elaraai/east").NullType;
-            readonly modest: import("@elaraai/east").NullType;
-            readonly adjustment_insufficient: import("@elaraai/east").NullType;
-            readonly non_identifiable_positivity: import("@elaraai/east").NullType;
-            readonly not_estimable: StringType;
-        }>;
-        readonly basis: import("@elaraai/east").VariantType<{
-            readonly detect_observed: import("@elaraai/east").NullType;
-            readonly resolve_vs_null: import("@elaraai/east").NullType;
-            readonly de_bias: import("@elaraai/east").NullType;
-            readonly restrict_to_overlap: import("@elaraai/east").NullType;
-            readonly create_control: import("@elaraai/east").NullType;
-        }>;
-        readonly target_effect: FloatType;
-        readonly outcome_sd: FloatType;
-        readonly target_power: FloatType;
-        readonly alpha: FloatType;
-        readonly current_power: import("@elaraai/east").OptionType<FloatType>;
-        readonly match_on: ArrayType<StringType>;
-        readonly options: ArrayType<StructType<{
-            readonly label: StringType;
-            readonly treated_share: FloatType;
-            readonly n_treated: IntegerType;
-            readonly n_control: IntegerType;
-            readonly n_total: IntegerType;
-        }>>;
-        readonly power_curve: StructType<{
-            readonly n: import("@elaraai/east").VectorType<IntegerType>;
-            readonly power: import("@elaraai/east").VectorType<FloatType>;
-        }>;
-        readonly rationale: StringType;
-    }>>;
-}>>, [variant<"field", "inputs">, variant<"field", "experiment_not_estimable_configs">]>;
-/** The two REFUSALS side-by-side. Positivity: no like-for-like comparison
- *  exists; the Answer tab renders the back-to-back propensity histogram
- *  instead of a number, and the hidden "How much?" tab demonstrates the
- *  dose-tab gating. Not-estimable: a 44-unit treated arm; the engine refuses
- *  with its reason string and the evidence counts. */
-export declare const experimentRefusals: import("@elaraai/east").ExampleDef<[], any>;
-//# sourceMappingURL=experiment.examples.d.ts.map