@elaraai/e3-ui 1.0.10 → 1.0.12

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

@@ -0,0 +1,535 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/** @jsxImportSource @elaraai/e3-ui */
+/**
+ * Experiment component example — an interactive causal-experiment surface over a
+ * generic manufacturing process. The worked question is *"did `slow_cure` change
+ * `bond_strength`?"* — a confounding-by-indication story: the optional slow-cure
+ * step is applied to the weaker incoming material, so the raw average makes it
+ * look worse (−3.1) while the like-for-like estimate flips it positive (+5.2).
+ *
+ * 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.
+ */
+import { ArrayType, StructType, BooleanType, FloatType, IntegerType, StringType, DateTimeType, variant } from '@elaraai/east';
+/** One production batch — the row struct the pickers are generic over. */
+export declare const BatchRow: StructType<{
+    readonly slow_cure: BooleanType;
+    readonly bond_strength: FloatType;
+    readonly incoming_grade: FloatType;
+    readonly mix_viscosity: FloatType;
+    readonly supplier: IntegerType;
+    readonly line: StringType;
+    readonly product: StringType;
+    readonly run_date: DateTimeType;
+}>;
+export declare const batchesInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
+    readonly slow_cure: BooleanType;
+    readonly bond_strength: FloatType;
+    readonly incoming_grade: FloatType;
+    readonly mix_viscosity: FloatType;
+    readonly supplier: IntegerType;
+    readonly line: StringType;
+    readonly product: StringType;
+    readonly run_date: DateTimeType;
+}>>, [variant<"field", "inputs">, variant<"field", "batches">]>;
+export declare const experimentSpecInput: 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 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 trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+        readonly overlap: import("@elaraai/east").NullType;
+        readonly bounds: StructType<{
+            readonly lower: FloatType;
+            readonly upper: FloatType;
+        }>;
+    }>>;
+}>, [variant<"field", "inputs">, variant<"field", "experiment_spec">]>;
+export declare const estimateFn: 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 trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+        readonly overlap: import("@elaraai/east").NullType;
+        readonly bounds: StructType<{
+            readonly lower: FloatType;
+            readonly upper: FloatType;
+        }>;
+    }>>;
+}>], StructType<{
+    readonly effect: FloatType;
+    readonly ci: import("@elaraai/east").OptionType<StructType<{
+        readonly lower: FloatType;
+        readonly upper: FloatType;
+    }>>;
+    readonly naive: FloatType;
+    readonly naiveCi: import("@elaraai/east").OptionType<StructType<{
+        readonly lower: FloatType;
+        readonly upper: FloatType;
+    }>>;
+    readonly nTotal: IntegerType;
+    readonly nTreated: IntegerType;
+    readonly nControl: IntegerType;
+    readonly nDropped: IntegerType;
+    readonly balance: ArrayType<StructType<{
+        readonly column: StringType;
+        readonly treatedMean: FloatType;
+        readonly controlMean: FloatType;
+        readonly stdDiff: FloatType;
+    }>>;
+}>>;
+export declare const refuteFn: 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 trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+        readonly overlap: import("@elaraai/east").NullType;
+        readonly bounds: StructType<{
+            readonly lower: FloatType;
+            readonly upper: 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>;
+    }>>;
+}>>;
+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 trim: import("@elaraai/east").OptionType<import("@elaraai/east").VariantType<{
+        readonly overlap: import("@elaraai/east").NullType;
+        readonly bounds: 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 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>>;
+    }>>>;
+}>>;
+export declare const experimentJournalInput: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
+    readonly spec: 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 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 effect: FloatType;
+    readonly ci: import("@elaraai/east").OptionType<StructType<{
+        readonly lower: FloatType;
+        readonly upper: FloatType;
+    }>>;
+    readonly committedAt: DateTimeType;
+    readonly committedBy: StringType;
+}>>, [variant<"field", "inputs">, variant<"field", "experiment_journal">]>;
+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>;
+//# sourceMappingURL=experiment.examples.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"experiment.examples.d.ts","sourceRoot":"","sources":["../../../test/experiment/experiment.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EACG,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAC9E,OAAO,EACtB,MAAM,eAAe,CAAC;AAUvB,0EAA0E;AAC1E,eAAO,MAAM,QAAQ;;;;;;;;;EASnB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;+DAavB,CAAC;AAMH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sEAY9B,CAAC;AAOH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYnB,CAAC;AAEL,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQjB,CAAC;AAEL,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GASf,CAAC;AAOL,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAajC,CAAC;AAMH,eAAO,MAAM,iBAAiB,6CAkB5B,CAAC;AAEH,eAAO,MAAM,eAAe,6CAkB1B,CAAC;AAEH,eAAO,MAAM,cAAc,6CAkBzB,CAAC"}