@elaraai/e3-ui 1.0.34 → 1.0.36

package/dist/src/decision/bind.d.ts

@@ -26,8 +26,7 @@
  *
  * @packageDocumentation
  */
-import { ArrayType, DictType, OptionType, StructType, VariantType, FunctionType, StringType, IntegerType, NullType, type EastType, type ExprType, type SubtypeExprOrValue } from '@elaraai/east';
-import { SliceStateType } from '@elaraai/east-ui/internal';
+import { ArrayType, DictType, OptionType, StructType, VariantType, FunctionType, StringType, IntegerType, NullType, type EastType, type ExprType } from '@elaraai/east';
 import { type BoundValue } from '../bind/data.js';
 import { DecisionType, DecisionConstraintType } from './types.js';
 /**
@@ -137,12 +136,6 @@ export type JudgementsType = typeof JudgementsType;
  *
  * @property decisions - Per-source binding descriptors
  * @property judgements - The judgements binding descriptor
- * @property sliceInit - The initial slice state passed at bind (data; feeds
- *   component payload refs)
- * @property slice - The handle-owned slice over the unioned queue (canonical
- *   `DecisionType` config; key derived from the bound source paths, like the
- *   selection). Components mount its rail; seeding `slice` at bind with no
- *   rail mounted gives an invisible author scope.
  * @property queue - The visible queue: union of every bound view (source ⊕
  *   patch each)
  * @property selected - The selected case id, if any
@@ -189,778 +182,6 @@ export declare function decisionHandleType<C extends EastType = DecisionConstrai
             readonly direct: NullType;
         }>;
     }>;
-    readonly sliceInit: OptionType<StructType<{
-        readonly range: OptionType<VariantType<{
-            readonly datetime: StructType<{
-                readonly from: import("@elaraai/east").DateTimeType;
-                readonly to: import("@elaraai/east").DateTimeType;
-            }>;
-            readonly datetimePreset: VariantType<{
-                readonly today: NullType;
-                readonly last7d: NullType;
-                readonly last30d: NullType;
-                readonly last90d: NullType;
-                readonly ytd: NullType;
-            }>;
-            readonly integer: StructType<{
-                readonly from: IntegerType;
-                readonly to: IntegerType;
-            }>;
-            readonly float: StructType<{
-                readonly from: import("@elaraai/east").FloatType;
-                readonly to: import("@elaraai/east").FloatType;
-            }>;
-        }>>;
-        readonly compare: OptionType<VariantType<{
-            readonly previousPeriod: NullType;
-            readonly previousYear: NullType;
-        }>>;
-        readonly filters: ArrayType<VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>>;
-        readonly cohorts: ArrayType<StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>>;
-        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-        readonly breakdown: OptionType<StructType<{
-            readonly fieldId: StringType;
-            readonly limit: OptionType<IntegerType>;
-        }>>;
-        readonly search: OptionType<StringType>;
-        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-        readonly selectedIndex: OptionType<IntegerType>;
-    }>>;
-    readonly slice: StructType<{
-        readonly key: StringType;
-        readonly read: FunctionType<[], StructType<{
-            readonly range: OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: VariantType<{
-                    readonly today: NullType;
-                    readonly last7d: NullType;
-                    readonly last30d: NullType;
-                    readonly last90d: NullType;
-                    readonly ytd: NullType;
-                }>;
-                readonly integer: StructType<{
-                    readonly from: IntegerType;
-                    readonly to: IntegerType;
-                }>;
-                readonly float: StructType<{
-                    readonly from: import("@elaraai/east").FloatType;
-                    readonly to: import("@elaraai/east").FloatType;
-                }>;
-            }>>;
-            readonly compare: OptionType<VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-            readonly cohorts: ArrayType<StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: IntegerType;
-                            readonly neq: IntegerType;
-                            readonly lt: IntegerType;
-                            readonly lte: IntegerType;
-                            readonly gt: IntegerType;
-                            readonly gte: IntegerType;
-                            readonly in: import("@elaraai/east").SetType<IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: 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: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>>;
-            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-            readonly breakdown: OptionType<StructType<{
-                readonly fieldId: StringType;
-                readonly limit: OptionType<IntegerType>;
-            }>>;
-            readonly search: OptionType<StringType>;
-            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-            readonly selectedIndex: OptionType<IntegerType>;
-        }>>;
-        readonly write: FunctionType<[StructType<{
-            readonly range: OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: VariantType<{
-                    readonly today: NullType;
-                    readonly last7d: NullType;
-                    readonly last30d: NullType;
-                    readonly last90d: NullType;
-                    readonly ytd: NullType;
-                }>;
-                readonly integer: StructType<{
-                    readonly from: IntegerType;
-                    readonly to: IntegerType;
-                }>;
-                readonly float: StructType<{
-                    readonly from: import("@elaraai/east").FloatType;
-                    readonly to: import("@elaraai/east").FloatType;
-                }>;
-            }>>;
-            readonly compare: OptionType<VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-            readonly cohorts: ArrayType<StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: IntegerType;
-                            readonly neq: IntegerType;
-                            readonly lt: IntegerType;
-                            readonly lte: IntegerType;
-                            readonly gt: IntegerType;
-                            readonly gte: IntegerType;
-                            readonly in: import("@elaraai/east").SetType<IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: 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: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>>;
-            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-            readonly breakdown: OptionType<StructType<{
-                readonly fieldId: StringType;
-                readonly limit: OptionType<IntegerType>;
-            }>>;
-            readonly search: OptionType<StringType>;
-            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-            readonly selectedIndex: OptionType<IntegerType>;
-        }>], NullType>;
-        readonly setRange: FunctionType<[OptionType<VariantType<{
-            readonly datetime: StructType<{
-                readonly from: import("@elaraai/east").DateTimeType;
-                readonly to: import("@elaraai/east").DateTimeType;
-            }>;
-            readonly datetimePreset: VariantType<{
-                readonly today: NullType;
-                readonly last7d: NullType;
-                readonly last30d: NullType;
-                readonly last90d: NullType;
-                readonly ytd: NullType;
-            }>;
-            readonly integer: StructType<{
-                readonly from: IntegerType;
-                readonly to: IntegerType;
-            }>;
-            readonly float: StructType<{
-                readonly from: import("@elaraai/east").FloatType;
-                readonly to: import("@elaraai/east").FloatType;
-            }>;
-        }>>], NullType>;
-        readonly setCompare: FunctionType<[OptionType<VariantType<{
-            readonly previousPeriod: NullType;
-            readonly previousYear: NullType;
-        }>>], NullType>;
-        readonly addFilter: FunctionType<[VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>], NullType>;
-        readonly removeFilter: FunctionType<[IntegerType], NullType>;
-        readonly clearFilters: FunctionType<[], NullType>;
-        readonly defineCohort: FunctionType<[StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>], NullType>;
-        readonly updateCohort: FunctionType<[StringType, StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>], NullType>;
-        readonly removeCohort: FunctionType<[StringType], NullType>;
-        readonly toggleCohort: FunctionType<[StringType], NullType>;
-        readonly setBreakdown: FunctionType<[OptionType<StructType<{
-            readonly fieldId: StringType;
-            readonly limit: OptionType<IntegerType>;
-        }>>], NullType>;
-        readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
-        readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
-        readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
-        readonly isActive: FunctionType<[], import("@elaraai/east").BooleanType>;
-        readonly activeCount: FunctionType<[], IntegerType>;
-        readonly dimensions: FunctionType<[], ArrayType<StructType<{
-            readonly fieldId: StringType;
-            readonly label: StringType;
-        }>>>;
-        readonly fields: FunctionType<[], ArrayType<StructType<{
-            readonly fieldId: StringType;
-            readonly label: StringType;
-            readonly kind: StringType;
-            readonly hints: ArrayType<StringType>;
-            readonly format: OptionType<VariantType<{
-                readonly number: NullType;
-                readonly currency: StructType<{
-                    readonly code: StringType;
-                    readonly compact: import("@elaraai/east").BooleanType;
-                }>;
-                readonly percent: NullType;
-                readonly compact: NullType;
-                readonly date: StringType;
-                readonly time: StringType;
-                readonly datetime: StringType;
-            }>>;
-        }>>>;
-        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
-        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
-        readonly totalCount: FunctionType<[], IntegerType>;
-        readonly resultCount: FunctionType<[], IntegerType>;
-        readonly groups: FunctionType<[], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly count: IntegerType;
-            readonly color: StringType;
-        }>>>;
-        readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly color: StringType;
-            readonly points: ArrayType<StructType<{
-                readonly x: VariantType<{
-                    readonly category: StringType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly time: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly value: import("@elaraai/east").FloatType;
-                readonly size: OptionType<import("@elaraai/east").FloatType>;
-                readonly color: OptionType<StringType>;
-            }>>;
-        }>>>;
-        readonly matches: FunctionType<[], ArrayType<StructType<{
-            readonly id: StringType;
-            readonly label: StringType;
-            readonly meta: OptionType<StringType>;
-        }>>>;
-        readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
-        readonly toggleFilter: FunctionType<[VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>], NullType>;
-        readonly facetGroups: FunctionType<[], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly count: IntegerType;
-            readonly color: StringType;
-        }>>>;
-    }>;
     readonly queue: FunctionType<[], ArrayType<StructType<{
         readonly id: StringType;
         readonly kind: StringType;
@@ -1630,778 +851,6 @@ export declare const DecisionHandleType: StructType<{
             readonly direct: NullType;
         }>;
     }>;
-    readonly sliceInit: OptionType<StructType<{
-        readonly range: OptionType<VariantType<{
-            readonly datetime: StructType<{
-                readonly from: import("@elaraai/east").DateTimeType;
-                readonly to: import("@elaraai/east").DateTimeType;
-            }>;
-            readonly datetimePreset: VariantType<{
-                readonly today: NullType;
-                readonly last7d: NullType;
-                readonly last30d: NullType;
-                readonly last90d: NullType;
-                readonly ytd: NullType;
-            }>;
-            readonly integer: StructType<{
-                readonly from: IntegerType;
-                readonly to: IntegerType;
-            }>;
-            readonly float: StructType<{
-                readonly from: import("@elaraai/east").FloatType;
-                readonly to: import("@elaraai/east").FloatType;
-            }>;
-        }>>;
-        readonly compare: OptionType<VariantType<{
-            readonly previousPeriod: NullType;
-            readonly previousYear: NullType;
-        }>>;
-        readonly filters: ArrayType<VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>>;
-        readonly cohorts: ArrayType<StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>>;
-        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-        readonly breakdown: OptionType<StructType<{
-            readonly fieldId: StringType;
-            readonly limit: OptionType<IntegerType>;
-        }>>;
-        readonly search: OptionType<StringType>;
-        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-        readonly selectedIndex: OptionType<IntegerType>;
-    }>>;
-    readonly slice: StructType<{
-        readonly key: StringType;
-        readonly read: FunctionType<[], StructType<{
-            readonly range: OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: VariantType<{
-                    readonly today: NullType;
-                    readonly last7d: NullType;
-                    readonly last30d: NullType;
-                    readonly last90d: NullType;
-                    readonly ytd: NullType;
-                }>;
-                readonly integer: StructType<{
-                    readonly from: IntegerType;
-                    readonly to: IntegerType;
-                }>;
-                readonly float: StructType<{
-                    readonly from: import("@elaraai/east").FloatType;
-                    readonly to: import("@elaraai/east").FloatType;
-                }>;
-            }>>;
-            readonly compare: OptionType<VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-            readonly cohorts: ArrayType<StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: IntegerType;
-                            readonly neq: IntegerType;
-                            readonly lt: IntegerType;
-                            readonly lte: IntegerType;
-                            readonly gt: IntegerType;
-                            readonly gte: IntegerType;
-                            readonly in: import("@elaraai/east").SetType<IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: 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: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>>;
-            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-            readonly breakdown: OptionType<StructType<{
-                readonly fieldId: StringType;
-                readonly limit: OptionType<IntegerType>;
-            }>>;
-            readonly search: OptionType<StringType>;
-            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-            readonly selectedIndex: OptionType<IntegerType>;
-        }>>;
-        readonly write: FunctionType<[StructType<{
-            readonly range: OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: VariantType<{
-                    readonly today: NullType;
-                    readonly last7d: NullType;
-                    readonly last30d: NullType;
-                    readonly last90d: NullType;
-                    readonly ytd: NullType;
-                }>;
-                readonly integer: StructType<{
-                    readonly from: IntegerType;
-                    readonly to: IntegerType;
-                }>;
-                readonly float: StructType<{
-                    readonly from: import("@elaraai/east").FloatType;
-                    readonly to: import("@elaraai/east").FloatType;
-                }>;
-            }>>;
-            readonly compare: OptionType<VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-            readonly cohorts: ArrayType<StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: IntegerType;
-                            readonly neq: IntegerType;
-                            readonly lt: IntegerType;
-                            readonly lte: IntegerType;
-                            readonly gt: IntegerType;
-                            readonly gte: IntegerType;
-                            readonly in: import("@elaraai/east").SetType<IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: 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: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>>;
-            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-            readonly breakdown: OptionType<StructType<{
-                readonly fieldId: StringType;
-                readonly limit: OptionType<IntegerType>;
-            }>>;
-            readonly search: OptionType<StringType>;
-            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-            readonly selectedIndex: OptionType<IntegerType>;
-        }>], NullType>;
-        readonly setRange: FunctionType<[OptionType<VariantType<{
-            readonly datetime: StructType<{
-                readonly from: import("@elaraai/east").DateTimeType;
-                readonly to: import("@elaraai/east").DateTimeType;
-            }>;
-            readonly datetimePreset: VariantType<{
-                readonly today: NullType;
-                readonly last7d: NullType;
-                readonly last30d: NullType;
-                readonly last90d: NullType;
-                readonly ytd: NullType;
-            }>;
-            readonly integer: StructType<{
-                readonly from: IntegerType;
-                readonly to: IntegerType;
-            }>;
-            readonly float: StructType<{
-                readonly from: import("@elaraai/east").FloatType;
-                readonly to: import("@elaraai/east").FloatType;
-            }>;
-        }>>], NullType>;
-        readonly setCompare: FunctionType<[OptionType<VariantType<{
-            readonly previousPeriod: NullType;
-            readonly previousYear: NullType;
-        }>>], NullType>;
-        readonly addFilter: FunctionType<[VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>], NullType>;
-        readonly removeFilter: FunctionType<[IntegerType], NullType>;
-        readonly clearFilters: FunctionType<[], NullType>;
-        readonly defineCohort: FunctionType<[StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>], NullType>;
-        readonly updateCohort: FunctionType<[StringType, StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>], NullType>;
-        readonly removeCohort: FunctionType<[StringType], NullType>;
-        readonly toggleCohort: FunctionType<[StringType], NullType>;
-        readonly setBreakdown: FunctionType<[OptionType<StructType<{
-            readonly fieldId: StringType;
-            readonly limit: OptionType<IntegerType>;
-        }>>], NullType>;
-        readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
-        readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
-        readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
-        readonly isActive: FunctionType<[], import("@elaraai/east").BooleanType>;
-        readonly activeCount: FunctionType<[], IntegerType>;
-        readonly dimensions: FunctionType<[], ArrayType<StructType<{
-            readonly fieldId: StringType;
-            readonly label: StringType;
-        }>>>;
-        readonly fields: FunctionType<[], ArrayType<StructType<{
-            readonly fieldId: StringType;
-            readonly label: StringType;
-            readonly kind: StringType;
-            readonly hints: ArrayType<StringType>;
-            readonly format: OptionType<VariantType<{
-                readonly number: NullType;
-                readonly currency: StructType<{
-                    readonly code: StringType;
-                    readonly compact: import("@elaraai/east").BooleanType;
-                }>;
-                readonly percent: NullType;
-                readonly compact: NullType;
-                readonly date: StringType;
-                readonly time: StringType;
-                readonly datetime: StringType;
-            }>>;
-        }>>>;
-        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
-        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
-        readonly totalCount: FunctionType<[], IntegerType>;
-        readonly resultCount: FunctionType<[], IntegerType>;
-        readonly groups: FunctionType<[], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly count: IntegerType;
-            readonly color: StringType;
-        }>>>;
-        readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly color: StringType;
-            readonly points: ArrayType<StructType<{
-                readonly x: VariantType<{
-                    readonly category: StringType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly time: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly value: import("@elaraai/east").FloatType;
-                readonly size: OptionType<import("@elaraai/east").FloatType>;
-                readonly color: OptionType<StringType>;
-            }>>;
-        }>>>;
-        readonly matches: FunctionType<[], ArrayType<StructType<{
-            readonly id: StringType;
-            readonly label: StringType;
-            readonly meta: OptionType<StringType>;
-        }>>>;
-        readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
-        readonly toggleFilter: FunctionType<[VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>], NullType>;
-        readonly facetGroups: FunctionType<[], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly count: IntegerType;
-            readonly color: StringType;
-        }>>>;
-    }>;
     readonly queue: FunctionType<[], ArrayType<StructType<{
         readonly id: StringType;
         readonly kind: StringType;
@@ -3124,7 +1573,7 @@ export type DecisionHandle<C extends EastType = DecisionConstraintType> = ExprTy
 /** What a surface needs from a handle of ANY contract — the descriptor
  *  fields its payload ref carries. Components accept this so one queue
  *  serves every solution contract. */
-export type DecisionHandleLike = Pick<DecisionHandle, 'decisions' | 'judgements' | 'sliceInit'>;
+export type DecisionHandleLike = Pick<DecisionHandle, 'decisions' | 'judgements'>;
 /**
  * The encodable identity of a handle — its binding descriptors. Extension
  * component payloads are beast2-encoded, so they carry this ref (plain
@@ -3159,155 +1608,6 @@ export declare const DecisionHandleRefType: StructType<{
             readonly direct: NullType;
         }>;
     }>;
-    readonly slice: OptionType<StructType<{
-        readonly range: OptionType<VariantType<{
-            readonly datetime: StructType<{
-                readonly from: import("@elaraai/east").DateTimeType;
-                readonly to: import("@elaraai/east").DateTimeType;
-            }>;
-            readonly datetimePreset: VariantType<{
-                readonly today: NullType;
-                readonly last7d: NullType;
-                readonly last30d: NullType;
-                readonly last90d: NullType;
-                readonly ytd: NullType;
-            }>;
-            readonly integer: StructType<{
-                readonly from: IntegerType;
-                readonly to: IntegerType;
-            }>;
-            readonly float: StructType<{
-                readonly from: import("@elaraai/east").FloatType;
-                readonly to: import("@elaraai/east").FloatType;
-            }>;
-        }>>;
-        readonly compare: OptionType<VariantType<{
-            readonly previousPeriod: NullType;
-            readonly previousYear: NullType;
-        }>>;
-        readonly filters: ArrayType<VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>>;
-        readonly cohorts: ArrayType<StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>>;
-        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-        readonly breakdown: OptionType<StructType<{
-            readonly fieldId: StringType;
-            readonly limit: OptionType<IntegerType>;
-        }>>;
-        readonly search: OptionType<StringType>;
-        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-        readonly selectedIndex: OptionType<IntegerType>;
-    }>>;
 }>;
 /** Type alias for {@link DecisionHandleRefType}. */
 export type DecisionHandleRefType = typeof DecisionHandleRefType;
@@ -3339,155 +1639,7 @@ export declare const decisionBindPlatformFn: import("@elaraai/east").GenericPlat
         readonly staged: NullType;
         readonly direct: NullType;
     }>;
-}>, OptionType<StructType<{
-    readonly range: OptionType<VariantType<{
-        readonly datetime: StructType<{
-            readonly from: import("@elaraai/east").DateTimeType;
-            readonly to: import("@elaraai/east").DateTimeType;
-        }>;
-        readonly datetimePreset: VariantType<{
-            readonly today: NullType;
-            readonly last7d: NullType;
-            readonly last30d: NullType;
-            readonly last90d: NullType;
-            readonly ytd: NullType;
-        }>;
-        readonly integer: StructType<{
-            readonly from: IntegerType;
-            readonly to: IntegerType;
-        }>;
-        readonly float: StructType<{
-            readonly from: import("@elaraai/east").FloatType;
-            readonly to: import("@elaraai/east").FloatType;
-        }>;
-    }>>;
-    readonly compare: OptionType<VariantType<{
-        readonly previousPeriod: NullType;
-        readonly previousYear: NullType;
-    }>>;
-    readonly filters: ArrayType<VariantType<{
-        readonly string: StructType<{
-            readonly fieldId: StringType;
-            readonly op: VariantType<{
-                readonly eq: StringType;
-                readonly neq: StringType;
-                readonly in: import("@elaraai/east").SetType<StringType>;
-                readonly notIn: import("@elaraai/east").SetType<StringType>;
-                readonly contains: StringType;
-                readonly matches: StringType;
-                readonly startsWith: StringType;
-                readonly endsWith: StringType;
-                readonly isEmpty: NullType;
-                readonly isNotEmpty: NullType;
-            }>;
-        }>;
-        readonly integer: StructType<{
-            readonly fieldId: StringType;
-            readonly op: VariantType<{
-                readonly eq: IntegerType;
-                readonly neq: IntegerType;
-                readonly lt: IntegerType;
-                readonly lte: IntegerType;
-                readonly gt: IntegerType;
-                readonly gte: IntegerType;
-                readonly in: import("@elaraai/east").SetType<IntegerType>;
-            }>;
-        }>;
-        readonly float: StructType<{
-            readonly fieldId: StringType;
-            readonly op: 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: StructType<{
-            readonly fieldId: StringType;
-            readonly op: VariantType<{
-                readonly before: import("@elaraai/east").DateTimeType;
-                readonly after: import("@elaraai/east").DateTimeType;
-                readonly between: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-            }>;
-        }>;
-        readonly boolean: StructType<{
-            readonly fieldId: StringType;
-            readonly op: VariantType<{
-                readonly is: import("@elaraai/east").BooleanType;
-            }>;
-        }>;
-    }>>;
-    readonly cohorts: ArrayType<StructType<{
-        readonly id: StringType;
-        readonly name: StringType;
-        readonly filters: ArrayType<VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>>;
-    }>>;
-    readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-    readonly breakdown: OptionType<StructType<{
-        readonly fieldId: StringType;
-        readonly limit: OptionType<IntegerType>;
-    }>>;
-    readonly search: OptionType<StringType>;
-    readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-    readonly selectedIndex: OptionType<IntegerType>;
-}>>], StructType<{
+}>], StructType<{
     readonly decisions: ArrayType<StructType<{
         readonly source: ArrayType<VariantType<{
             readonly field: StringType;
@@ -3512,778 +1664,6 @@ export declare const decisionBindPlatformFn: import("@elaraai/east").GenericPlat
             readonly direct: NullType;
         }>;
     }>;
-    readonly sliceInit: OptionType<StructType<{
-        readonly range: OptionType<VariantType<{
-            readonly datetime: StructType<{
-                readonly from: import("@elaraai/east").DateTimeType;
-                readonly to: import("@elaraai/east").DateTimeType;
-            }>;
-            readonly datetimePreset: VariantType<{
-                readonly today: NullType;
-                readonly last7d: NullType;
-                readonly last30d: NullType;
-                readonly last90d: NullType;
-                readonly ytd: NullType;
-            }>;
-            readonly integer: StructType<{
-                readonly from: IntegerType;
-                readonly to: IntegerType;
-            }>;
-            readonly float: StructType<{
-                readonly from: import("@elaraai/east").FloatType;
-                readonly to: import("@elaraai/east").FloatType;
-            }>;
-        }>>;
-        readonly compare: OptionType<VariantType<{
-            readonly previousPeriod: NullType;
-            readonly previousYear: NullType;
-        }>>;
-        readonly filters: ArrayType<VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>>;
-        readonly cohorts: ArrayType<StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>>;
-        readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-        readonly breakdown: OptionType<StructType<{
-            readonly fieldId: StringType;
-            readonly limit: OptionType<IntegerType>;
-        }>>;
-        readonly search: OptionType<StringType>;
-        readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-        readonly selectedIndex: OptionType<IntegerType>;
-    }>>;
-    readonly slice: StructType<{
-        readonly key: StringType;
-        readonly read: FunctionType<[], StructType<{
-            readonly range: OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: VariantType<{
-                    readonly today: NullType;
-                    readonly last7d: NullType;
-                    readonly last30d: NullType;
-                    readonly last90d: NullType;
-                    readonly ytd: NullType;
-                }>;
-                readonly integer: StructType<{
-                    readonly from: IntegerType;
-                    readonly to: IntegerType;
-                }>;
-                readonly float: StructType<{
-                    readonly from: import("@elaraai/east").FloatType;
-                    readonly to: import("@elaraai/east").FloatType;
-                }>;
-            }>>;
-            readonly compare: OptionType<VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-            readonly cohorts: ArrayType<StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: IntegerType;
-                            readonly neq: IntegerType;
-                            readonly lt: IntegerType;
-                            readonly lte: IntegerType;
-                            readonly gt: IntegerType;
-                            readonly gte: IntegerType;
-                            readonly in: import("@elaraai/east").SetType<IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: 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: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>>;
-            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-            readonly breakdown: OptionType<StructType<{
-                readonly fieldId: StringType;
-                readonly limit: OptionType<IntegerType>;
-            }>>;
-            readonly search: OptionType<StringType>;
-            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-            readonly selectedIndex: OptionType<IntegerType>;
-        }>>;
-        readonly write: FunctionType<[StructType<{
-            readonly range: OptionType<VariantType<{
-                readonly datetime: StructType<{
-                    readonly from: import("@elaraai/east").DateTimeType;
-                    readonly to: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly datetimePreset: VariantType<{
-                    readonly today: NullType;
-                    readonly last7d: NullType;
-                    readonly last30d: NullType;
-                    readonly last90d: NullType;
-                    readonly ytd: NullType;
-                }>;
-                readonly integer: StructType<{
-                    readonly from: IntegerType;
-                    readonly to: IntegerType;
-                }>;
-                readonly float: StructType<{
-                    readonly from: import("@elaraai/east").FloatType;
-                    readonly to: import("@elaraai/east").FloatType;
-                }>;
-            }>>;
-            readonly compare: OptionType<VariantType<{
-                readonly previousPeriod: NullType;
-                readonly previousYear: NullType;
-            }>>;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-            readonly cohorts: ArrayType<StructType<{
-                readonly id: StringType;
-                readonly name: StringType;
-                readonly filters: ArrayType<VariantType<{
-                    readonly string: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: StringType;
-                            readonly neq: StringType;
-                            readonly in: import("@elaraai/east").SetType<StringType>;
-                            readonly notIn: import("@elaraai/east").SetType<StringType>;
-                            readonly contains: StringType;
-                            readonly matches: StringType;
-                            readonly startsWith: StringType;
-                            readonly endsWith: StringType;
-                            readonly isEmpty: NullType;
-                            readonly isNotEmpty: NullType;
-                        }>;
-                    }>;
-                    readonly integer: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly eq: IntegerType;
-                            readonly neq: IntegerType;
-                            readonly lt: IntegerType;
-                            readonly lte: IntegerType;
-                            readonly gt: IntegerType;
-                            readonly gte: IntegerType;
-                            readonly in: import("@elaraai/east").SetType<IntegerType>;
-                        }>;
-                    }>;
-                    readonly float: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: 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: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly before: import("@elaraai/east").DateTimeType;
-                            readonly after: import("@elaraai/east").DateTimeType;
-                            readonly between: StructType<{
-                                readonly from: import("@elaraai/east").DateTimeType;
-                                readonly to: import("@elaraai/east").DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                    readonly boolean: StructType<{
-                        readonly fieldId: StringType;
-                        readonly op: VariantType<{
-                            readonly is: import("@elaraai/east").BooleanType;
-                        }>;
-                    }>;
-                }>>;
-            }>>;
-            readonly activeCohorts: import("@elaraai/east").SetType<StringType>;
-            readonly breakdown: OptionType<StructType<{
-                readonly fieldId: StringType;
-                readonly limit: OptionType<IntegerType>;
-            }>>;
-            readonly search: OptionType<StringType>;
-            readonly visible: OptionType<import("@elaraai/east").SetType<StringType>>;
-            readonly selectedIndex: OptionType<IntegerType>;
-        }>], NullType>;
-        readonly setRange: FunctionType<[OptionType<VariantType<{
-            readonly datetime: StructType<{
-                readonly from: import("@elaraai/east").DateTimeType;
-                readonly to: import("@elaraai/east").DateTimeType;
-            }>;
-            readonly datetimePreset: VariantType<{
-                readonly today: NullType;
-                readonly last7d: NullType;
-                readonly last30d: NullType;
-                readonly last90d: NullType;
-                readonly ytd: NullType;
-            }>;
-            readonly integer: StructType<{
-                readonly from: IntegerType;
-                readonly to: IntegerType;
-            }>;
-            readonly float: StructType<{
-                readonly from: import("@elaraai/east").FloatType;
-                readonly to: import("@elaraai/east").FloatType;
-            }>;
-        }>>], NullType>;
-        readonly setCompare: FunctionType<[OptionType<VariantType<{
-            readonly previousPeriod: NullType;
-            readonly previousYear: NullType;
-        }>>], NullType>;
-        readonly addFilter: FunctionType<[VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>], NullType>;
-        readonly removeFilter: FunctionType<[IntegerType], NullType>;
-        readonly clearFilters: FunctionType<[], NullType>;
-        readonly defineCohort: FunctionType<[StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>], NullType>;
-        readonly updateCohort: FunctionType<[StringType, StructType<{
-            readonly id: StringType;
-            readonly name: StringType;
-            readonly filters: ArrayType<VariantType<{
-                readonly string: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: StringType;
-                        readonly neq: StringType;
-                        readonly in: import("@elaraai/east").SetType<StringType>;
-                        readonly notIn: import("@elaraai/east").SetType<StringType>;
-                        readonly contains: StringType;
-                        readonly matches: StringType;
-                        readonly startsWith: StringType;
-                        readonly endsWith: StringType;
-                        readonly isEmpty: NullType;
-                        readonly isNotEmpty: NullType;
-                    }>;
-                }>;
-                readonly integer: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly eq: IntegerType;
-                        readonly neq: IntegerType;
-                        readonly lt: IntegerType;
-                        readonly lte: IntegerType;
-                        readonly gt: IntegerType;
-                        readonly gte: IntegerType;
-                        readonly in: import("@elaraai/east").SetType<IntegerType>;
-                    }>;
-                }>;
-                readonly float: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: 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: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly before: import("@elaraai/east").DateTimeType;
-                        readonly after: import("@elaraai/east").DateTimeType;
-                        readonly between: StructType<{
-                            readonly from: import("@elaraai/east").DateTimeType;
-                            readonly to: import("@elaraai/east").DateTimeType;
-                        }>;
-                    }>;
-                }>;
-                readonly boolean: StructType<{
-                    readonly fieldId: StringType;
-                    readonly op: VariantType<{
-                        readonly is: import("@elaraai/east").BooleanType;
-                    }>;
-                }>;
-            }>>;
-        }>], NullType>;
-        readonly removeCohort: FunctionType<[StringType], NullType>;
-        readonly toggleCohort: FunctionType<[StringType], NullType>;
-        readonly setBreakdown: FunctionType<[OptionType<StructType<{
-            readonly fieldId: StringType;
-            readonly limit: OptionType<IntegerType>;
-        }>>], NullType>;
-        readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
-        readonly setVisible: FunctionType<[OptionType<import("@elaraai/east").SetType<StringType>>], NullType>;
-        readonly select: FunctionType<[OptionType<IntegerType>], NullType>;
-        readonly isActive: FunctionType<[], import("@elaraai/east").BooleanType>;
-        readonly activeCount: FunctionType<[], IntegerType>;
-        readonly dimensions: FunctionType<[], ArrayType<StructType<{
-            readonly fieldId: StringType;
-            readonly label: StringType;
-        }>>>;
-        readonly fields: FunctionType<[], ArrayType<StructType<{
-            readonly fieldId: StringType;
-            readonly label: StringType;
-            readonly kind: StringType;
-            readonly hints: ArrayType<StringType>;
-            readonly format: OptionType<VariantType<{
-                readonly number: NullType;
-                readonly currency: StructType<{
-                    readonly code: StringType;
-                    readonly compact: import("@elaraai/east").BooleanType;
-                }>;
-                readonly percent: NullType;
-                readonly compact: NullType;
-                readonly date: StringType;
-                readonly time: StringType;
-                readonly datetime: StringType;
-            }>>;
-        }>>>;
-        readonly searchFieldIds: FunctionType<[], ArrayType<StringType>>;
-        readonly rangeFieldId: FunctionType<[], OptionType<StringType>>;
-        readonly totalCount: FunctionType<[], IntegerType>;
-        readonly resultCount: FunctionType<[], IntegerType>;
-        readonly groups: FunctionType<[], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly count: IntegerType;
-            readonly color: StringType;
-        }>>>;
-        readonly series: FunctionType<[StringType, StringType], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly color: StringType;
-            readonly points: ArrayType<StructType<{
-                readonly x: VariantType<{
-                    readonly category: StringType;
-                    readonly number: import("@elaraai/east").FloatType;
-                    readonly time: import("@elaraai/east").DateTimeType;
-                }>;
-                readonly value: import("@elaraai/east").FloatType;
-                readonly size: OptionType<import("@elaraai/east").FloatType>;
-                readonly color: OptionType<StringType>;
-            }>>;
-        }>>>;
-        readonly matches: FunctionType<[], ArrayType<StructType<{
-            readonly id: StringType;
-            readonly label: StringType;
-            readonly meta: OptionType<StringType>;
-        }>>>;
-        readonly cohortCounts: FunctionType<[], DictType<StringType, IntegerType>>;
-        readonly toggleFilter: FunctionType<[VariantType<{
-            readonly string: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: StringType;
-                    readonly neq: StringType;
-                    readonly in: import("@elaraai/east").SetType<StringType>;
-                    readonly notIn: import("@elaraai/east").SetType<StringType>;
-                    readonly contains: StringType;
-                    readonly matches: StringType;
-                    readonly startsWith: StringType;
-                    readonly endsWith: StringType;
-                    readonly isEmpty: NullType;
-                    readonly isNotEmpty: NullType;
-                }>;
-            }>;
-            readonly integer: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly eq: IntegerType;
-                    readonly neq: IntegerType;
-                    readonly lt: IntegerType;
-                    readonly lte: IntegerType;
-                    readonly gt: IntegerType;
-                    readonly gte: IntegerType;
-                    readonly in: import("@elaraai/east").SetType<IntegerType>;
-                }>;
-            }>;
-            readonly float: StructType<{
-                readonly fieldId: StringType;
-                readonly op: 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: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly before: import("@elaraai/east").DateTimeType;
-                    readonly after: import("@elaraai/east").DateTimeType;
-                    readonly between: StructType<{
-                        readonly from: import("@elaraai/east").DateTimeType;
-                        readonly to: import("@elaraai/east").DateTimeType;
-                    }>;
-                }>;
-            }>;
-            readonly boolean: StructType<{
-                readonly fieldId: StringType;
-                readonly op: VariantType<{
-                    readonly is: import("@elaraai/east").BooleanType;
-                }>;
-            }>;
-        }>], NullType>;
-        readonly facetGroups: FunctionType<[], ArrayType<StructType<{
-            readonly key: StringType;
-            readonly count: IntegerType;
-            readonly color: StringType;
-        }>>>;
-    }>;
     readonly queue: FunctionType<[], ArrayType<StructType<{
         readonly id: StringType;
         readonly kind: StringType;
@@ -5709,15 +3089,10 @@ export declare const DecisionBindPrimitives: {
  * @property judgements - The bound judgements view —
  *   `Data.bind(…)` (the staged
  *   operator input)
- * @property slice - Optional initial state for the handle-owned slice over
- *   the queue (`Slice.state({ filters: [...] })`). Seeded once; the
- *   operator's rail edits write over it. With no rail mounted on the queue
- *   it acts as an invisible author scope.
  */
 export interface DecisionBindOptions<C extends EastType = DecisionConstraintType> {
     decisions: BoundValue<ArrayType<DecisionType>>[];
     judgements: BoundValue<ReturnType<typeof judgementsType<C>>>;
-    slice?: SubtypeExprOrValue<SliceStateType>;
 }
 /**
  * Build a decision handle from bound decision views + the bound judgements