@elaraai/e3-ui 1.0.11 → 1.0.13

package/dist/src/experiment/index.d.ts

@@ -0,0 +1,694 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `Experiment` component — an interactive causal-experiment surface.
+ *
+ * @remarks
+ * `Experiment` lets a domain expert ask *"did X change Y, and can I trust it?"*
+ * against a dataset and read a derived, honest answer — without meeting a
+ * statistician's vocabulary. It is a registered extension component
+ * (architecturally like {@link Ontology}): the author writes one tag,
+ * `Experiment.Root({ … })`; the React renderer lives in
+ * `@elaraai/e3-ui-components`.
+ *
+ * **Generic over the input row, like `Table`.** The author binds the input
+ * dataset (`data: BoundValue<ArrayType<Row>>`); the renderer introspects its row
+ * struct to drive the treatment / outcome / confounder pickers.
+ *
+ * **The user edits the config → Apply runs ONE function.** Editing a picker
+ * stages a new {@link ExperimentConfigType}; **Apply** calls the single bound
+ * `experiment` function (`(rows, config) → ExperimentResult`) and the answer
+ * arrives reactively. The result carries the naive vs adjusted effect, balance,
+ * overlap, robustness, and an honesty **verdict** — `adjusted` is `none` when the
+ * engine refuses. **Commit** appends to the journal.
+ *
+ * **Visual-first and derived.** Nothing on the result side is hand-authored —
+ * every word is a column name the user picked, a number the engine returned, or
+ * a status derived by rule from the verdict tag.
+ *
+ * @packageDocumentation
+ */
+import { NullType, BooleanType, ArrayType, StructType, VariantType, OptionType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
+import { type UIComponentType } from '@elaraai/east-ui';
+import { type BoundValue } from '../data.js';
+import { type BoundFunc } from '../func.js';
+import { ExperimentConfigType, ExperimentResultType, JournalType, PopulationType, DesignConfigType, ExperimentDesignType } from './types.js';
+export { CiType, WeightingSchemeType, EstimatorType, TargetUnitsType, BootstrapConfigType, RefuteSpecType, ExperimentConfigType, BalanceRowType, OverlapDiagnosticType, RefutationType, DoseResponseType, ExperimentVerdictType, ExperimentResultType, JournalRowType, JournalType, ColumnMetaType, PopulationType, } from './types.js';
+/**
+ * The `experiment` function signature: `(rows, config) → ExperimentResult`. The
+ * renderer calls this on **Apply** with the bound `data` and the staged config.
+ *
+ * @typeParam Row - The input dataset's row struct.
+ */
+export type ExperimentFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentConfigType], ExperimentResultType>;
+export type ExperimentDesignFunc<Row extends StructType> = BoundFunc<[ArrayType<Row>, ExperimentConfigType, ExperimentResultType, DesignConfigType], ExperimentDesignType>;
+/** Initial result tab variant — `answer` (default), `trust`, `dose`, or `validate`. */
+export declare const ExperimentTabType: VariantType<{
+    readonly answer: NullType;
+    readonly trust: NullType;
+    readonly dose: NullType;
+    readonly validate: NullType;
+}>;
+/** Type alias for {@link ExperimentTabType}. */
+export type ExperimentTabType = typeof ExperimentTabType;
+/**
+ * The `Experiment` component payload — binding descriptors + options. Renderers
+ * decode this and resolve each binding to a live, reactive value / call handle.
+ *
+ * @property data - {@link DiffBindingType} for the input dataset — the renderer
+ *   introspects its row struct for the pickers and passes it to the function.
+ * @property config - {@link DiffBindingType} for the staged {@link ExperimentConfigType}.
+ * @property experiment - {@link FuncBindingType} for the single `experiment` function.
+ * @property population - Optional {@link DiffBindingType} for the staged Step-4
+ *   population filter ({@link PopulationType}); narrows rows UI-side before the call.
+ * @property journal - Optional {@link DiffBindingType} for the committed-experiment journal.
+ * @property columnMeta - Optional per-column display metadata.
+ * @property readonly - Render without the Apply / Commit / edit affordances.
+ * @property defaultTab - Initial result tab ({@link ExperimentTabType}).
+ */
+export declare const ExperimentPayloadType: StructType<{
+    readonly data: StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+    readonly config: StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+    readonly experiment: StructType<{
+        readonly name: import("@elaraai/east").StringType;
+    }>;
+    readonly population: OptionType<StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>>;
+    readonly journal: OptionType<StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>>;
+    /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
+    readonly design: OptionType<StructType<{
+        readonly name: import("@elaraai/east").StringType;
+    }>>;
+    readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+        readonly label: OptionType<import("@elaraai/east").StringType>;
+        readonly unit: OptionType<import("@elaraai/east").StringType>;
+        readonly higherIsBetter: OptionType<BooleanType>;
+    }>>>;
+    readonly readonly: OptionType<BooleanType>;
+    readonly defaultTab: OptionType<VariantType<{
+        readonly answer: NullType;
+        readonly trust: NullType;
+        readonly dose: NullType;
+        readonly validate: NullType;
+    }>>;
+}>;
+/** Type alias for {@link ExperimentPayloadType}. */
+export type ExperimentPayloadType = typeof ExperimentPayloadType;
+/** Initial result tab as a string literal. */
+export type ExperimentTabLiteral = 'answer' | 'trust' | 'dose';
+/**
+ * Internal {@link EastUI.component} carrier. The React renderer registers
+ * against this in `@elaraai/e3-ui-components`.
+ */
+export declare const ExperimentComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
+    readonly data: StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+    readonly config: StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>;
+    readonly experiment: StructType<{
+        readonly name: import("@elaraai/east").StringType;
+    }>;
+    readonly population: OptionType<StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>>;
+    readonly journal: OptionType<StructType<{
+        readonly source: ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>;
+        readonly patch: OptionType<ArrayType<VariantType<{
+            readonly field: import("@elaraai/east").StringType;
+        }>>>;
+        readonly mode: VariantType<{
+            readonly staged: NullType;
+            readonly direct: NullType;
+        }>;
+    }>>;
+    /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
+    readonly design: OptionType<StructType<{
+        readonly name: import("@elaraai/east").StringType;
+    }>>;
+    readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+        readonly label: OptionType<import("@elaraai/east").StringType>;
+        readonly unit: OptionType<import("@elaraai/east").StringType>;
+        readonly higherIsBetter: OptionType<BooleanType>;
+    }>>>;
+    readonly readonly: OptionType<BooleanType>;
+    readonly defaultTab: OptionType<VariantType<{
+        readonly answer: NullType;
+        readonly trust: NullType;
+        readonly dose: NullType;
+        readonly validate: NullType;
+    }>>;
+}>>;
+/**
+ * Per-column display config — the friendly label, unit suffix, and good
+ * direction the surface uses to phrase results ("worse" instead of "lower").
+ */
+export interface ExperimentColumnConfig {
+    /** Friendly label shown instead of the raw column name. */
+    label?: string;
+    /** Unit suffix ("MPa", "$", …). */
+    unit?: string;
+    /** Whether a larger value is the good direction (flips "lower" → "worse"). */
+    higherIsBetter?: boolean;
+}
+/**
+ * Type-safe per-column config, keyed by the bound dataset's field names (the
+ * `Table` columns pattern) — only real columns are accepted as keys.
+ *
+ * @typeParam Row - The input dataset's row struct.
+ */
+export type ExperimentColumns<Row extends StructType> = {
+    [K in Extract<keyof Row['fields'], string>]?: ExperimentColumnConfig;
+};
+/**
+ * Options for {@link Experiment.Root}, generic over the input row struct.
+ *
+ * @typeParam Row - The input dataset's row struct — inferred from `data`.
+ *
+ * @property data - The {@link Data.bind} handle for the input dataset.
+ * @property config - The {@link Data.bind} handle for the staged experiment config.
+ * @property experiment - The {@link Func.bind} handle for the experiment function.
+ * @property population - Optional {@link Data.bind} handle for the staged Step-4
+ *   population filter (a {@link PopulationType}); narrows the rows UI-side before
+ *   the call. Bind it (seeded) to start with filters applied.
+ * @property journal - Optional {@link Data.bind} handle for the committed-experiment journal.
+ * @property columns - Optional per-column display config.
+ * @property readonly - Render without mutation affordances.
+ * @property defaultTab - Initial result tab.
+ */
+export interface ExperimentOptions<Row extends StructType> {
+    data: BoundValue<ArrayType<Row>>;
+    config: BoundValue<ExperimentConfigType>;
+    experiment: ExperimentFunc<Row>;
+    /** Optional `design` function — adds the "Validate" tab (the trial recipe). */
+    design?: ExperimentDesignFunc<Row>;
+    population?: BoundValue<PopulationType>;
+    journal?: BoundValue<JournalType>;
+    /** Per-column display config, keyed by the data row's fields (like `Table`). */
+    columns?: ExperimentColumns<Row>;
+    readonly?: SubtypeExprOrValue<OptionType<BooleanType>>;
+    defaultTab?: ExperimentTabLiteral;
+}
+/**
+ * Build an Experiment surface bound to an input dataset + the single experiment
+ * function.
+ *
+ * @typeParam Row - The input dataset's row struct, inferred from `data`.
+ * @param options - {@link ExperimentOptions}. `data`, `config` and `experiment`
+ *   are required; the rest are optional.
+ * @returns An East expression of {@link UIComponentType}.
+ */
+declare function createExperiment<Row extends StructType>(options: ExperimentOptions<Row>): ExprType<UIComponentType>;
+/**
+ * The Experiment component namespace. Surfaces an interactive causal-experiment
+ * over a bound input dataset + a single `experiment` function, generic over the
+ * row struct (the `Table` pattern).
+ *
+ * @remarks
+ * Use `Experiment.Root({ data, config, experiment, journal })` inside a
+ * `Reactive` block. `Types` exposes the render-contract value types (`Config`,
+ * `Result`, `Verdict`, `Overlap`, `Balance`, `Refutation`, `Journal`, …).
+ */
+export declare const Experiment: {
+    readonly Root: typeof createExperiment;
+    /** The internal {@link EastUI.component} carrier renderers register against. */
+    readonly Component: import("@elaraai/east-ui").UIComponentDef<StructType<{
+        readonly data: StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>;
+        readonly config: StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>;
+        readonly experiment: StructType<{
+            readonly name: import("@elaraai/east").StringType;
+        }>;
+        readonly population: OptionType<StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>>;
+        readonly journal: OptionType<StructType<{
+            readonly source: ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>;
+            readonly patch: OptionType<ArrayType<VariantType<{
+                readonly field: import("@elaraai/east").StringType;
+            }>>>;
+            readonly mode: VariantType<{
+                readonly staged: NullType;
+                readonly direct: NullType;
+            }>;
+        }>>;
+        /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
+        readonly design: OptionType<StructType<{
+            readonly name: import("@elaraai/east").StringType;
+        }>>;
+        readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+            readonly label: OptionType<import("@elaraai/east").StringType>;
+            readonly unit: OptionType<import("@elaraai/east").StringType>;
+            readonly higherIsBetter: OptionType<BooleanType>;
+        }>>>;
+        readonly readonly: OptionType<BooleanType>;
+        readonly defaultTab: OptionType<VariantType<{
+            readonly answer: NullType;
+            readonly trust: NullType;
+            readonly dose: NullType;
+            readonly validate: NullType;
+        }>>;
+    }>>;
+    readonly Types: {
+        /** Rendered payload struct (bindings + options). */
+        readonly Payload: StructType<{
+            readonly data: StructType<{
+                readonly source: ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>;
+                readonly patch: OptionType<ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>>;
+                readonly mode: VariantType<{
+                    readonly staged: NullType;
+                    readonly direct: NullType;
+                }>;
+            }>;
+            readonly config: StructType<{
+                readonly source: ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>;
+                readonly patch: OptionType<ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>>;
+                readonly mode: VariantType<{
+                    readonly staged: NullType;
+                    readonly direct: NullType;
+                }>;
+            }>;
+            readonly experiment: StructType<{
+                readonly name: import("@elaraai/east").StringType;
+            }>;
+            readonly population: OptionType<StructType<{
+                readonly source: ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>;
+                readonly patch: OptionType<ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>>;
+                readonly mode: VariantType<{
+                    readonly staged: NullType;
+                    readonly direct: NullType;
+                }>;
+            }>>;
+            readonly journal: OptionType<StructType<{
+                readonly source: ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>;
+                readonly patch: OptionType<ArrayType<VariantType<{
+                    readonly field: import("@elaraai/east").StringType;
+                }>>>;
+                readonly mode: VariantType<{
+                    readonly staged: NullType;
+                    readonly direct: NullType;
+                }>;
+            }>>;
+            /** Optional `design` function → the validation-trial recipe ("Validate" tab). */
+            readonly design: OptionType<StructType<{
+                readonly name: import("@elaraai/east").StringType;
+            }>>;
+            readonly columnMeta: OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+                readonly label: OptionType<import("@elaraai/east").StringType>;
+                readonly unit: OptionType<import("@elaraai/east").StringType>;
+                readonly higherIsBetter: OptionType<BooleanType>;
+            }>>>;
+            readonly readonly: OptionType<BooleanType>;
+            readonly defaultTab: OptionType<VariantType<{
+                readonly answer: NullType;
+                readonly trust: NullType;
+                readonly dose: NullType;
+                readonly validate: NullType;
+            }>>;
+        }>;
+        /** The experiment-config value type (what the pickers stage). */
+        readonly Config: StructType<{
+            readonly treatment: import("@elaraai/east").StringType;
+            readonly outcome: import("@elaraai/east").StringType;
+            readonly common_causes: ArrayType<import("@elaraai/east").StringType>;
+            readonly categorical: OptionType<ArrayType<import("@elaraai/east").StringType>>;
+            readonly method: OptionType<VariantType<{
+                readonly linear_regression: NullType;
+                readonly propensity_score_weighting: StructType<{
+                    readonly weighting_scheme: OptionType<VariantType<{
+                        readonly ips_weight: NullType;
+                        readonly ips_stabilized_weight: NullType;
+                        readonly ips_normalized_weight: NullType;
+                    }>>;
+                }>;
+            }>>;
+            readonly estimand: OptionType<VariantType<{
+                readonly ate: NullType;
+                readonly att: NullType;
+                readonly atc: NullType;
+            }>>;
+            readonly refute: OptionType<StructType<{
+                readonly placebo: BooleanType;
+                readonly random_common_cause: BooleanType;
+                readonly data_subset: BooleanType;
+                readonly sensitivity: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
+            }>>;
+            readonly dose_feature: OptionType<import("@elaraai/east").StringType>;
+            readonly min_overlap: OptionType<import("@elaraai/east").FloatType>;
+            readonly min_treatment_variation: OptionType<import("@elaraai/east").FloatType>;
+            readonly bootstrap: OptionType<StructType<{
+                readonly reps: import("@elaraai/east").IntegerType;
+                readonly cluster_column: OptionType<import("@elaraai/east").StringType>;
+                readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
+            }>>;
+            readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
+        }>;
+        /** The result value type (numbers + verdict). */
+        readonly Result: StructType<{
+            readonly naive: import("@elaraai/east").FloatType;
+            readonly naive_ci: OptionType<StructType<{
+                readonly lower: import("@elaraai/east").FloatType;
+                readonly upper: import("@elaraai/east").FloatType;
+            }>>;
+            readonly adjusted: OptionType<StructType<{
+                readonly effect: import("@elaraai/east").FloatType;
+                readonly ci: OptionType<StructType<{
+                    readonly lower: import("@elaraai/east").FloatType;
+                    readonly upper: import("@elaraai/east").FloatType;
+                }>>;
+            }>>;
+            readonly n_total: import("@elaraai/east").IntegerType;
+            readonly n_treated: import("@elaraai/east").IntegerType;
+            readonly n_control: import("@elaraai/east").IntegerType;
+            readonly n_dropped: import("@elaraai/east").IntegerType;
+            readonly balance: ArrayType<StructType<{
+                readonly column: import("@elaraai/east").StringType;
+                readonly base_column: import("@elaraai/east").StringType;
+                readonly treated_mean: import("@elaraai/east").FloatType;
+                readonly control_mean: import("@elaraai/east").FloatType;
+                readonly std_diff: import("@elaraai/east").FloatType;
+            }>>;
+            readonly overlap: StructType<{
+                readonly treated_propensity: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly control_propensity: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly common_support_frac: import("@elaraai/east").FloatType;
+                readonly positivity_ok: BooleanType;
+            }>;
+            readonly refutation: OptionType<StructType<{
+                readonly placebo_effect: OptionType<import("@elaraai/east").FloatType>;
+                readonly placebo_passes: OptionType<BooleanType>;
+                readonly random_cc_within_ci: OptionType<BooleanType>;
+                readonly data_subset_effect: OptionType<import("@elaraai/east").FloatType>;
+                readonly data_subset_std: OptionType<import("@elaraai/east").FloatType>;
+                readonly robustness_value: OptionType<import("@elaraai/east").FloatType>;
+                readonly sensitivity: OptionType<StructType<{
+                    readonly strengths: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                    readonly effects: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                }>>;
+            }>>;
+            readonly dose_response: OptionType<StructType<{
+                readonly feature: import("@elaraai/east").StringType;
+                readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+                readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+                readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+                readonly size: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
+            }>>;
+            readonly verdict: VariantType<{
+                readonly causal: NullType;
+                readonly modest: NullType;
+                readonly adjustment_insufficient: NullType;
+                readonly non_identifiable_positivity: NullType;
+                readonly not_estimable: import("@elaraai/east").StringType;
+            }>;
+        }>;
+        /** The ALE dose-response curve value type (the "How much?" tab). */
+        readonly DoseResponse: StructType<{
+            readonly feature: import("@elaraai/east").StringType;
+            readonly grid: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+            readonly effect: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+            readonly lower: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+            readonly upper: OptionType<import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>>;
+            readonly size: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
+        }>;
+        /** The committed-experiment journal value type. */
+        readonly Journal: ArrayType<StructType<{
+            readonly config: StructType<{
+                readonly treatment: import("@elaraai/east").StringType;
+                readonly outcome: import("@elaraai/east").StringType;
+                readonly common_causes: ArrayType<import("@elaraai/east").StringType>;
+                readonly categorical: OptionType<ArrayType<import("@elaraai/east").StringType>>;
+                readonly method: OptionType<VariantType<{
+                    readonly linear_regression: NullType;
+                    readonly propensity_score_weighting: StructType<{
+                        readonly weighting_scheme: OptionType<VariantType<{
+                            readonly ips_weight: NullType;
+                            readonly ips_stabilized_weight: NullType;
+                            readonly ips_normalized_weight: NullType;
+                        }>>;
+                    }>;
+                }>>;
+                readonly estimand: OptionType<VariantType<{
+                    readonly ate: NullType;
+                    readonly att: NullType;
+                    readonly atc: NullType;
+                }>>;
+                readonly refute: OptionType<StructType<{
+                    readonly placebo: BooleanType;
+                    readonly random_common_cause: BooleanType;
+                    readonly data_subset: BooleanType;
+                    readonly sensitivity: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
+                }>>;
+                readonly dose_feature: OptionType<import("@elaraai/east").StringType>;
+                readonly min_overlap: OptionType<import("@elaraai/east").FloatType>;
+                readonly min_treatment_variation: OptionType<import("@elaraai/east").FloatType>;
+                readonly bootstrap: OptionType<StructType<{
+                    readonly reps: import("@elaraai/east").IntegerType;
+                    readonly cluster_column: OptionType<import("@elaraai/east").StringType>;
+                    readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
+                }>>;
+                readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            readonly verdict: VariantType<{
+                readonly causal: NullType;
+                readonly modest: NullType;
+                readonly adjustment_insufficient: NullType;
+                readonly non_identifiable_positivity: NullType;
+                readonly not_estimable: import("@elaraai/east").StringType;
+            }>;
+            readonly naive: import("@elaraai/east").FloatType;
+            readonly adjusted: OptionType<import("@elaraai/east").FloatType>;
+            readonly committed_at: import("@elaraai/east").DateTimeType;
+            readonly committed_by: import("@elaraai/east").StringType;
+        }>>;
+        /** The validation-trial recipe value type (the "Validate" tab). */
+        readonly Design: StructType<{
+            readonly verdict: VariantType<{
+                readonly causal: NullType;
+                readonly modest: NullType;
+                readonly adjustment_insufficient: NullType;
+                readonly non_identifiable_positivity: NullType;
+                readonly not_estimable: import("@elaraai/east").StringType;
+            }>;
+            readonly basis: VariantType<{
+                readonly detect_observed: NullType;
+                readonly resolve_vs_null: NullType;
+                readonly de_bias: NullType;
+                readonly restrict_to_overlap: NullType;
+                readonly create_control: NullType;
+            }>;
+            readonly target_effect: import("@elaraai/east").FloatType;
+            readonly outcome_sd: import("@elaraai/east").FloatType;
+            readonly target_power: import("@elaraai/east").FloatType;
+            readonly alpha: import("@elaraai/east").FloatType;
+            readonly current_power: OptionType<import("@elaraai/east").FloatType>;
+            readonly match_on: ArrayType<import("@elaraai/east").StringType>;
+            readonly options: ArrayType<StructType<{
+                readonly label: import("@elaraai/east").StringType;
+                readonly treated_share: import("@elaraai/east").FloatType;
+                readonly n_treated: import("@elaraai/east").IntegerType;
+                readonly n_control: import("@elaraai/east").IntegerType;
+                readonly n_total: import("@elaraai/east").IntegerType;
+            }>>;
+            readonly power_curve: StructType<{
+                readonly n: import("@elaraai/east").VectorType<import("@elaraai/east").IntegerType>;
+                readonly power: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
+            }>;
+            readonly rationale: import("@elaraai/east").StringType;
+        }>;
+        /** The optional design-knobs value type. */
+        readonly DesignConfig: StructType<{
+            readonly alpha: OptionType<import("@elaraai/east").FloatType>;
+            readonly target_power: OptionType<import("@elaraai/east").FloatType>;
+            readonly materiality: OptionType<import("@elaraai/east").FloatType>;
+            readonly treated_shares: OptionType<ArrayType<import("@elaraai/east").FloatType>>;
+        }>;
+        /** The UI-side Step-4 population filter value type (Array of Slice predicates). */
+        readonly Population: ArrayType<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;
+                }>;
+            }>;
+        }>>;
+        /** Optional per-column display metadata. */
+        readonly ColumnMeta: import("@elaraai/east").DictType<import("@elaraai/east").StringType, StructType<{
+            readonly label: OptionType<import("@elaraai/east").StringType>;
+            readonly unit: OptionType<import("@elaraai/east").StringType>;
+            readonly higherIsBetter: OptionType<BooleanType>;
+        }>>;
+        /** Initial result tab variant. */
+        readonly Tab: VariantType<{
+            readonly answer: NullType;
+            readonly trust: NullType;
+            readonly dose: NullType;
+            readonly validate: NullType;
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map