@elaraai/e3-ui 1.0.103 → 1.0.104

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

@@ -1,1033 +0,0 @@
-/**
- * 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, StringType, StructType, VariantType, OptionType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
-import { type UIComponentType } from '@elaraai/east-ui';
-import { type BoundValue } from '../bind/data.js';
-import { type BoundFunc } from '../bind/func.js';
-import { ExperimentConfigType, ExperimentResultType, JournalType, ConfigurationType, DesignConfigType, ExperimentDesignType } from './types.js';
-export { CiType, WeightingSchemeType, EstimatorType, TargetUnitsType, BootstrapConfigType, RefuteSpecType, ExperimentConfigType, BalanceRowType, SensitivityBenchmarkType, OverlapDiagnosticType, RefutationType, DoseResponseType, ExperimentVerdictType, VerdictReasonType, ExperimentResultType, JournalRowType, JournalType, ColumnMetaType, PopulationType, ConfigurationType, } 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 domain noun for one row of the bound dataset — singular + plural (e.g.
- * `{ one: 'batch', many: 'batches' }`). The surface interpolates it everywhere
- * it speaks about rows ("Which batches?", "480 batches", the guidance
- * glossary), replacing the neutral default `record(s)`.
- */
-export declare const ExperimentSubjectType: StructType<{
-    readonly one: StringType;
-    readonly many: StringType;
-}>;
-/** Type alias for {@link ExperimentSubjectType}. */
-export type ExperimentSubjectType = typeof ExperimentSubjectType;
-/**
- * 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 configs - {@link DiffBindingType} for the list of {@link ConfigurationType}
- *   questions (each carrying its config + optional precomputed result/design). The
- *   only config source; selecting one seeds the working config.
- * @property experiment - Optional {@link FuncBindingType} for the universal estimator
- *   function; omitted when every shown question carries a precomputed result.
- * @property journal - Optional {@link DiffBindingType} for the committed-experiment journal.
- * @property design - Optional {@link FuncBindingType} for the universal `design` function
- *   (the "Validate" tab); applies to any question.
- * @property columnMeta - Optional per-column display metadata.
- * @property subject - Optional domain noun for a row ({@link ExperimentSubjectType}).
- * @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: StringType;
-        }>>;
-        readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>>;
-        readonly mode: VariantType<{
-            readonly staged: NullType;
-            readonly direct: NullType;
-        }>;
-    }>;
-    readonly configs: StructType<{
-        readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>;
-        readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>>;
-        readonly mode: VariantType<{
-            readonly staged: NullType;
-            readonly direct: NullType;
-        }>;
-    }>;
-    readonly experiment: OptionType<StructType<{
-        readonly name: StringType;
-    }>>;
-    readonly journal: OptionType<StructType<{
-        readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>;
-        readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>>;
-        readonly mode: VariantType<{
-            readonly staged: NullType;
-            readonly direct: NullType;
-        }>;
-    }>>;
-    readonly design: OptionType<StructType<{
-        readonly name: StringType;
-    }>>;
-    readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
-        readonly label: OptionType<StringType>;
-        readonly unit: OptionType<StringType>;
-        readonly higherIsBetter: OptionType<BooleanType>;
-    }>>>;
-    readonly subject: OptionType<StructType<{
-        readonly one: StringType;
-        readonly many: StringType;
-    }>>;
-    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' | 'validate';
-/**
- * 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: StringType;
-        }>>;
-        readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>>;
-        readonly mode: VariantType<{
-            readonly staged: NullType;
-            readonly direct: NullType;
-        }>;
-    }>;
-    readonly configs: StructType<{
-        readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>;
-        readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>>;
-        readonly mode: VariantType<{
-            readonly staged: NullType;
-            readonly direct: NullType;
-        }>;
-    }>;
-    readonly experiment: OptionType<StructType<{
-        readonly name: StringType;
-    }>>;
-    readonly journal: OptionType<StructType<{
-        readonly source: ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>;
-        readonly patch: OptionType<ArrayType<VariantType<{
-            readonly field: StringType;
-        }>>>;
-        readonly mode: VariantType<{
-            readonly staged: NullType;
-            readonly direct: NullType;
-        }>;
-    }>>;
-    readonly design: OptionType<StructType<{
-        readonly name: StringType;
-    }>>;
-    readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
-        readonly label: OptionType<StringType>;
-        readonly unit: OptionType<StringType>;
-        readonly higherIsBetter: OptionType<BooleanType>;
-    }>>>;
-    readonly subject: OptionType<StructType<{
-        readonly one: StringType;
-        readonly many: StringType;
-    }>>;
-    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 configs - The {@link Data.bind} handle for the list of
- *   {@link ConfigurationType} questions (each carrying its config + optional
- *   precomputed result/design). The only config source.
- * @property experiment - Optional {@link Func.bind} handle for the universal
- *   estimator function; omit when every shown question carries a precomputed result.
- * @property design - Optional {@link Func.bind} handle for the universal `design`
- *   function (adds the "Validate" tab); omit when no question needs the trial recipe
- *   or every shown question carries a precomputed `design`.
- * @property journal - Optional {@link Data.bind} handle for the committed-experiment journal.
- * @property columns - Optional per-column display config.
- * @property subject - Optional domain noun for a row (`'batch'`, or `{ one, many }`).
- * @property readonly - Render without mutation affordances.
- * @property defaultTab - Initial result tab.
- */
-export interface ExperimentOptions<Row extends StructType> {
-    data: BoundValue<ArrayType<Row>>;
-    /** The questions — and their optional precomputed answers. The only config source. */
-    configs: BoundValue<ArrayType<ConfigurationType>>;
-    /** Optional universal estimator. One function serves every config; omit when every
-     *  shown question carries a precomputed `result`. */
-    experiment?: ExperimentFunc<Row>;
-    /** Optional `design` function — adds the "Validate" tab (the trial recipe). */
-    design?: ExperimentDesignFunc<Row>;
-    journal?: BoundValue<JournalType>;
-    /** Per-column display config, keyed by the data row's fields (like `Table`). */
-    columns?: ExperimentColumns<Row>;
-    /** The domain noun for one row — a singular string (`'batch'`, auto-pluralised)
-     *  or an explicit `{ one, many }` pair for irregular plurals. Replaces the
-     *  neutral `record(s)` everywhere the surface speaks about rows. */
-    subject?: string | {
-        one: string;
-        many: string;
-    };
-    readonly?: SubtypeExprOrValue<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` and `configs` 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: StringType;
-            }>>;
-            readonly patch: OptionType<ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>>;
-            readonly mode: VariantType<{
-                readonly staged: NullType;
-                readonly direct: NullType;
-            }>;
-        }>;
-        readonly configs: StructType<{
-            readonly source: ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>;
-            readonly patch: OptionType<ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>>;
-            readonly mode: VariantType<{
-                readonly staged: NullType;
-                readonly direct: NullType;
-            }>;
-        }>;
-        readonly experiment: OptionType<StructType<{
-            readonly name: StringType;
-        }>>;
-        readonly journal: OptionType<StructType<{
-            readonly source: ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>;
-            readonly patch: OptionType<ArrayType<VariantType<{
-                readonly field: StringType;
-            }>>>;
-            readonly mode: VariantType<{
-                readonly staged: NullType;
-                readonly direct: NullType;
-            }>;
-        }>>;
-        readonly design: OptionType<StructType<{
-            readonly name: StringType;
-        }>>;
-        readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
-            readonly label: OptionType<StringType>;
-            readonly unit: OptionType<StringType>;
-            readonly higherIsBetter: OptionType<BooleanType>;
-        }>>>;
-        readonly subject: OptionType<StructType<{
-            readonly one: StringType;
-            readonly many: StringType;
-        }>>;
-        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: StringType;
-                }>>;
-                readonly patch: OptionType<ArrayType<VariantType<{
-                    readonly field: StringType;
-                }>>>;
-                readonly mode: VariantType<{
-                    readonly staged: NullType;
-                    readonly direct: NullType;
-                }>;
-            }>;
-            readonly configs: StructType<{
-                readonly source: ArrayType<VariantType<{
-                    readonly field: StringType;
-                }>>;
-                readonly patch: OptionType<ArrayType<VariantType<{
-                    readonly field: StringType;
-                }>>>;
-                readonly mode: VariantType<{
-                    readonly staged: NullType;
-                    readonly direct: NullType;
-                }>;
-            }>;
-            readonly experiment: OptionType<StructType<{
-                readonly name: StringType;
-            }>>;
-            readonly journal: OptionType<StructType<{
-                readonly source: ArrayType<VariantType<{
-                    readonly field: StringType;
-                }>>;
-                readonly patch: OptionType<ArrayType<VariantType<{
-                    readonly field: StringType;
-                }>>>;
-                readonly mode: VariantType<{
-                    readonly staged: NullType;
-                    readonly direct: NullType;
-                }>;
-            }>>;
-            readonly design: OptionType<StructType<{
-                readonly name: StringType;
-            }>>;
-            readonly columnMeta: OptionType<import("@elaraai/east").DictType<StringType, StructType<{
-                readonly label: OptionType<StringType>;
-                readonly unit: OptionType<StringType>;
-                readonly higherIsBetter: OptionType<BooleanType>;
-            }>>>;
-            readonly subject: OptionType<StructType<{
-                readonly one: StringType;
-                readonly many: StringType;
-            }>>;
-            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: StringType;
-            readonly outcome: StringType;
-            readonly common_causes: ArrayType<StringType>;
-            readonly categorical: OptionType<ArrayType<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<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<StringType>;
-                readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
-            }>>;
-            readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
-            readonly strong_overlap: OptionType<import("@elaraai/east").FloatType>;
-            readonly evalue_floor: OptionType<import("@elaraai/east").FloatType>;
-            readonly expected_sign: OptionType<VariantType<{
-                readonly positive: NullType;
-                readonly negative: NullType;
-            }>>;
-        }>;
-        /** 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: StringType;
-                readonly base_column: StringType;
-                readonly treated_mean: import("@elaraai/east").FloatType;
-                readonly control_mean: import("@elaraai/east").FloatType;
-                readonly std_diff: import("@elaraai/east").FloatType;
-                readonly std_diff_adjusted: OptionType<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 support_strength: VariantType<{
-                    readonly refused: NullType;
-                    readonly thin: NullType;
-                    readonly strong: NullType;
-                }>;
-            }>;
-            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 benchmarks: ArrayType<StructType<{
-                        readonly column: StringType;
-                        readonly strength: import("@elaraai/east").FloatType;
-                    }>>;
-                }>>;
-                readonly expected_sign_ok: OptionType<BooleanType>;
-            }>>;
-            readonly dose_response: OptionType<StructType<{
-                readonly feature: 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: StringType;
-            }>;
-            readonly verdict_reasons: ArrayType<VariantType<{
-                readonly placebo_failed: NullType;
-                readonly not_material: NullType;
-                readonly ci_spans_zero: NullType;
-                readonly wrong_sign: NullType;
-                readonly thin_support: NullType;
-                readonly low_robustness: NullType;
-            }>>;
-            readonly outcome_sd: import("@elaraai/east").FloatType;
-            readonly materiality_threshold: import("@elaraai/east").FloatType;
-            readonly treated_outcome_mean: OptionType<import("@elaraai/east").FloatType>;
-            readonly control_outcome_mean: OptionType<import("@elaraai/east").FloatType>;
-        }>;
-        /** A confidence interval. */
-        readonly Ci: StructType<{
-            readonly lower: import("@elaraai/east").FloatType;
-            readonly upper: import("@elaraai/east").FloatType;
-        }>;
-        /** The adjusted (like-for-like) effect + CI. */
-        readonly Adjusted: StructType<{
-            readonly effect: import("@elaraai/east").FloatType;
-            readonly ci: OptionType<StructType<{
-                readonly lower: import("@elaraai/east").FloatType;
-                readonly upper: import("@elaraai/east").FloatType;
-            }>>;
-        }>;
-        /** One confounder's before-adjustment imbalance (a balance row). */
-        readonly Balance: StructType<{
-            readonly column: StringType;
-            readonly base_column: StringType;
-            readonly treated_mean: import("@elaraai/east").FloatType;
-            readonly control_mean: import("@elaraai/east").FloatType;
-            readonly std_diff: import("@elaraai/east").FloatType;
-            readonly std_diff_adjusted: OptionType<import("@elaraai/east").FloatType>;
-        }>;
-        /** The propensity-overlap diagnostic. */
-        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 support_strength: VariantType<{
-                readonly refused: NullType;
-                readonly thin: NullType;
-                readonly strong: NullType;
-            }>;
-        }>;
-        /** The robustness summary. */
-        readonly Refutation: 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 benchmarks: ArrayType<StructType<{
-                    readonly column: StringType;
-                    readonly strength: import("@elaraai/east").FloatType;
-                }>>;
-            }>>;
-            readonly expected_sign_ok: OptionType<BooleanType>;
-        }>;
-        /** The unobserved-confounder sensitivity (tipping) curve. */
-        readonly Sensitivity: StructType<{
-            readonly strengths: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
-            readonly effects: import("@elaraai/east").VectorType<import("@elaraai/east").FloatType>;
-            readonly benchmarks: ArrayType<StructType<{
-                readonly column: StringType;
-                readonly strength: import("@elaraai/east").FloatType;
-            }>>;
-        }>;
-        /** One observed confounder benchmarked on the sensitivity strengths axis. */
-        readonly SensitivityBenchmark: StructType<{
-            readonly column: StringType;
-            readonly strength: import("@elaraai/east").FloatType;
-        }>;
-        /** The honesty verdict tag. */
-        readonly Verdict: VariantType<{
-            readonly causal: NullType;
-            readonly modest: NullType;
-            readonly adjustment_insufficient: NullType;
-            readonly non_identifiable_positivity: NullType;
-            readonly not_estimable: StringType;
-        }>;
-        /** Machine-readable reason a verdict fell short of `causal`. */
-        readonly VerdictReason: VariantType<{
-            readonly placebo_failed: NullType;
-            readonly not_material: NullType;
-            readonly ci_spans_zero: NullType;
-            readonly wrong_sign: NullType;
-            readonly thin_support: NullType;
-            readonly low_robustness: NullType;
-        }>;
-        /** The ALE dose-response curve value type (the "How much?" tab). */
-        readonly DoseResponse: StructType<{
-            readonly feature: 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: StringType;
-                readonly outcome: StringType;
-                readonly common_causes: ArrayType<StringType>;
-                readonly categorical: OptionType<ArrayType<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<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<StringType>;
-                    readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
-                }>>;
-                readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
-                readonly strong_overlap: OptionType<import("@elaraai/east").FloatType>;
-                readonly evalue_floor: OptionType<import("@elaraai/east").FloatType>;
-                readonly expected_sign: OptionType<VariantType<{
-                    readonly positive: NullType;
-                    readonly negative: NullType;
-                }>>;
-            }>;
-            readonly verdict: VariantType<{
-                readonly causal: NullType;
-                readonly modest: NullType;
-                readonly adjustment_insufficient: NullType;
-                readonly non_identifiable_positivity: NullType;
-                readonly not_estimable: StringType;
-            }>;
-            readonly naive: import("@elaraai/east").FloatType;
-            readonly adjusted: OptionType<import("@elaraai/east").FloatType>;
-            readonly committed_at: import("@elaraai/east").DateTimeType;
-            readonly committed_by: StringType;
-            readonly preset: OptionType<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: 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<StringType>;
-            readonly options: ArrayType<StructType<{
-                readonly label: 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: 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 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;
-                }>;
-            }>;
-        }>>;
-        /** A configuration value type — a named question + scope + optional precomputed answer. */
-        readonly Configuration: StructType<{
-            readonly id: StringType;
-            readonly label: StringType;
-            readonly spec: StructType<{
-                readonly treatment: StringType;
-                readonly outcome: StringType;
-                readonly common_causes: ArrayType<StringType>;
-                readonly categorical: OptionType<ArrayType<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<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<StringType>;
-                    readonly confidence_level: OptionType<import("@elaraai/east").FloatType>;
-                }>>;
-                readonly random_state: OptionType<import("@elaraai/east").IntegerType>;
-                readonly strong_overlap: OptionType<import("@elaraai/east").FloatType>;
-                readonly evalue_floor: OptionType<import("@elaraai/east").FloatType>;
-                readonly expected_sign: OptionType<VariantType<{
-                    readonly positive: NullType;
-                    readonly negative: NullType;
-                }>>;
-            }>;
-            readonly population: OptionType<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 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: OptionType<StringType>;
-            readonly result: OptionType<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: StringType;
-                    readonly base_column: StringType;
-                    readonly treated_mean: import("@elaraai/east").FloatType;
-                    readonly control_mean: import("@elaraai/east").FloatType;
-                    readonly std_diff: import("@elaraai/east").FloatType;
-                    readonly std_diff_adjusted: OptionType<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 support_strength: VariantType<{
-                        readonly refused: NullType;
-                        readonly thin: NullType;
-                        readonly strong: NullType;
-                    }>;
-                }>;
-                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 benchmarks: ArrayType<StructType<{
-                            readonly column: StringType;
-                            readonly strength: import("@elaraai/east").FloatType;
-                        }>>;
-                    }>>;
-                    readonly expected_sign_ok: OptionType<BooleanType>;
-                }>>;
-                readonly dose_response: OptionType<StructType<{
-                    readonly feature: 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: StringType;
-                }>;
-                readonly verdict_reasons: ArrayType<VariantType<{
-                    readonly placebo_failed: NullType;
-                    readonly not_material: NullType;
-                    readonly ci_spans_zero: NullType;
-                    readonly wrong_sign: NullType;
-                    readonly thin_support: NullType;
-                    readonly low_robustness: NullType;
-                }>>;
-                readonly outcome_sd: import("@elaraai/east").FloatType;
-                readonly materiality_threshold: import("@elaraai/east").FloatType;
-                readonly treated_outcome_mean: OptionType<import("@elaraai/east").FloatType>;
-                readonly control_outcome_mean: OptionType<import("@elaraai/east").FloatType>;
-            }>>;
-            readonly design: OptionType<StructType<{
-                readonly verdict: VariantType<{
-                    readonly causal: NullType;
-                    readonly modest: NullType;
-                    readonly adjustment_insufficient: NullType;
-                    readonly non_identifiable_positivity: NullType;
-                    readonly not_estimable: 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<StringType>;
-                readonly options: ArrayType<StructType<{
-                    readonly label: 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: StringType;
-            }>>;
-        }>;
-        /** Optional per-column display metadata. */
-        readonly ColumnMeta: import("@elaraai/east").DictType<StringType, StructType<{
-            readonly label: OptionType<StringType>;
-            readonly unit: OptionType<StringType>;
-            readonly higherIsBetter: OptionType<BooleanType>;
-        }>>;
-        /** Optional domain noun for a row (singular + plural). */
-        readonly Subject: StructType<{
-            readonly one: StringType;
-            readonly many: StringType;
-        }>;
-        /** Initial result tab variant. */
-        readonly Tab: VariantType<{
-            readonly answer: NullType;
-            readonly trust: NullType;
-            readonly dose: NullType;
-            readonly validate: NullType;
-        }>;
-    };
-};
-//# sourceMappingURL=index.d.ts.map