@elaraai/e3-ui 1.0.12 → 1.0.14

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

@@ -8,25 +8,25 @@
  * 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).
+ * 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), [...])` — the **input dataset**. The
  *      renderer introspects this row struct to drive the treatment / outcome /
  *      confounder pickers, exactly like `Table`.
- *   2. `e3.input('experiment_spec', Experiment.Types.Spec, {...})` — the staged
- *      experiment the pickers edit.
- *   3. Three `e3.function`s — `estimate` / `refute` / `dose` — that return the
- *      `Experiment.Types.*` numeric contract. In production their bodies call
- *      east-py-datascience's (generic) Causal functions; here they are pure-East
- *      fixtures returning the constants the real estimator would (mirroring the
- *      `causalEffectConfounding` example), so the surface runs offline with no
- *      datascience dependency. The numbers the snapshot harness seeds for these
- *      functions live in `e3-ui-components/snapshot/main.tsx`, imported from here
- *      so the two copies cannot drift.
- *   4. `<Experiment data spec estimate refute dose journal />`. The renderer
- *      auto-runs on mount, derives every word / colour / bar from the returned
- *      numbers, and re-runs when the user edits the spec.
+ *   2. `e3.input('experiment_config', Experiment.Types.Config, {...})` — the
+ *      staged config the pickers edit (snake_case; structurally identical to
+ *      east-py-datascience's `Causal.Types.CausalExperimentConfigType`).
+ *   3. ONE `e3.function('experiment', (rows, config) → ExperimentResult)`. In
+ *      production its body calls east-py-datascience's `Causal.experiment`; here
+ *      it is a pure-East fixture returning the constants the real engine would,
+ *      so the surface runs offline with no datascience dependency. The snapshot
+ *      harness compiles this body to seed the function — the numbers live only
+ *      here, so the two copies cannot drift.
+ *   4. `<Experiment data config experiment journal />`. The renderer auto-runs on
+ *      mount, derives every word / colour / bar from the single returned result
+ *      and 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. */
@@ -50,62 +50,11 @@ export declare const batchesInput: import("@elaraai/e3").DatasetDef<ArrayType<St
     readonly product: StringType;
     readonly run_date: DateTimeType;
 }>>, [variant<"field", "inputs">, variant<"field", "batches">]>;
-export declare const experimentSpecInput: import("@elaraai/e3").DatasetDef<StructType<{
+export declare const experimentConfigInput: import("@elaraai/e3").DatasetDef<StructType<{
     readonly treatment: StringType;
     readonly outcome: StringType;
-    readonly confounders: ArrayType<StringType>;
-    readonly categorical: ArrayType<StringType>;
-    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 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 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<{
@@ -116,20 +65,28 @@ export declare const experimentSpecInput: import("@elaraai/e3").DatasetDef<Struc
             }>>;
         }>;
     }>>;
-    readonly targetUnits: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+    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 trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly overlap: import("@elaraai/east").NullType;
-        readonly bounds: StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>;
+    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>;
     }>>;
-}>, [variant<"field", "inputs">, variant<"field", "experiment_spec">]>;
-export declare const estimateFn: import("@elaraai/e3").FunctionDef<[ArrayType<StructType<{
+    readonly random_state: import("@elaraai/east").OptionType<IntegerType>;
+}>, [variant<"field", "inputs">, variant<"field", "experiment_config">]>;
+export declare const experimentFn: import("@elaraai/e3").FunctionDef<[ArrayType<StructType<{
     readonly slow_cure: BooleanType;
     readonly bond_strength: FloatType;
     readonly incoming_grade: FloatType;
@@ -141,59 +98,8 @@ export declare const estimateFn: import("@elaraai/e3").FunctionDef<[ArrayType<St
 }>>, StructType<{
     readonly treatment: StringType;
     readonly outcome: StringType;
-    readonly confounders: ArrayType<StringType>;
-    readonly categorical: ArrayType<StringType>;
-    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 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 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<{
@@ -204,41 +110,85 @@ export declare const estimateFn: import("@elaraai/e3").FunctionDef<[ArrayType<St
             }>>;
         }>;
     }>>;
-    readonly targetUnits: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+    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 trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly overlap: import("@elaraai/east").NullType;
-        readonly bounds: StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>;
+    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>>;
     }>>;
-}>], StructType<{
-    readonly effect: FloatType;
-    readonly ci: import("@elaraai/east").OptionType<StructType<{
-        readonly lower: FloatType;
-        readonly upper: 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>;
+}>], StructType<{
     readonly naive: FloatType;
-    readonly naiveCi: import("@elaraai/east").OptionType<StructType<{
+    readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
         readonly lower: FloatType;
         readonly upper: FloatType;
     }>>;
-    readonly nTotal: IntegerType;
-    readonly nTreated: IntegerType;
-    readonly nControl: IntegerType;
-    readonly nDropped: IntegerType;
+    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 treatedMean: FloatType;
-        readonly controlMean: FloatType;
-        readonly stdDiff: FloatType;
+        readonly base_column: StringType;
+        readonly treated_mean: FloatType;
+        readonly control_mean: FloatType;
+        readonly std_diff: 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 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 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;
+    }>;
 }>>;
-export declare const refuteFn: import("@elaraai/e3").FunctionDef<[ArrayType<StructType<{
+export declare const designFn: import("@elaraai/e3").FunctionDef<[ArrayType<StructType<{
     readonly slow_cure: BooleanType;
     readonly bond_strength: FloatType;
     readonly incoming_grade: FloatType;
@@ -250,59 +200,8 @@ export declare const refuteFn: import("@elaraai/e3").FunctionDef<[ArrayType<Stru
 }>>, StructType<{
     readonly treatment: StringType;
     readonly outcome: StringType;
-    readonly confounders: ArrayType<StringType>;
-    readonly categorical: ArrayType<StringType>;
-    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 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 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<{
@@ -313,191 +212,128 @@ export declare const refuteFn: import("@elaraai/e3").FunctionDef<[ArrayType<Stru
             }>>;
         }>;
     }>>;
-    readonly targetUnits: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+    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 trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly overlap: import("@elaraai/east").NullType;
-        readonly bounds: StructType<{
-            readonly lower: FloatType;
-            readonly upper: FloatType;
-        }>;
+    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>>;
     }>>;
-}>], StructType<{
-    readonly checks: ArrayType<StructType<{
-        readonly kind: import("@elaraai/east").VariantType<{
-            readonly placebo: import("@elaraai/east").NullType;
-            readonly random_common_cause: import("@elaraai/east").NullType;
-            readonly data_subset: import("@elaraai/east").NullType;
-            readonly unobserved: import("@elaraai/east").NullType;
-        }>;
-        readonly estimatedEffect: FloatType;
-        readonly newEffects: import("@elaraai/east").VectorType<FloatType>;
-        readonly strengths: import("@elaraai/east").OptionType<import("@elaraai/east").VectorType<FloatType>>;
-        readonly pValue: import("@elaraai/east").OptionType<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>;
     }>>;
-}>>;
-export declare const doseFn: 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 confounders: ArrayType<StringType>;
-    readonly categorical: ArrayType<StringType>;
-    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 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 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 targetUnits: 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 random_state: import("@elaraai/east").OptionType<IntegerType>;
+}>, StructType<{
+    readonly naive: FloatType;
+    readonly naive_ci: import("@elaraai/east").OptionType<StructType<{
+        readonly lower: FloatType;
+        readonly upper: FloatType;
     }>>;
-    readonly trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-        readonly overlap: import("@elaraai/east").NullType;
-        readonly bounds: StructType<{
+    readonly adjusted: import("@elaraai/east").OptionType<StructType<{
+        readonly effect: FloatType;
+        readonly ci: import("@elaraai/east").OptionType<StructType<{
             readonly lower: FloatType;
             readonly upper: FloatType;
-        }>;
+        }>>;
     }>>;
-}>, StringType], 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 segments: import("@elaraai/east").OptionType<ArrayType<StructType<{
-        readonly label: StringType;
+    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 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 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 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;
+    }>;
+}>, 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;
 }>>;
 export declare const experimentJournalInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly spec: StructType<{
+    readonly config: StructType<{
         readonly treatment: StringType;
         readonly outcome: StringType;
-        readonly confounders: ArrayType<StringType>;
-        readonly categorical: ArrayType<StringType>;
-        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 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 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<{
@@ -508,28 +344,92 @@ export declare const experimentJournalInput: import("@elaraai/e3").DatasetDef<Ar
                 }>>;
             }>;
         }>>;
-        readonly targetUnits: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+        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 trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
-            readonly overlap: import("@elaraai/east").NullType;
-            readonly bounds: StructType<{
-                readonly lower: FloatType;
-                readonly upper: FloatType;
-            }>;
+        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 effect: FloatType;
-    readonly ci: import("@elaraai/east").OptionType<StructType<{
-        readonly lower: FloatType;
-        readonly upper: FloatType;
-    }>>;
-    readonly committedAt: DateTimeType;
-    readonly committedBy: StringType;
+    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;
 }>>, [variant<"field", "inputs">, variant<"field", "experiment_journal">]>;
+export declare const experimentPopulationInput: import("@elaraai/e3").DatasetDef<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 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;
+        }>;
+    }>;
+}>>, [variant<"field", "inputs">, variant<"field", "experiment_population">]>;
 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>;
 //# sourceMappingURL=experiment.examples.d.ts.map