@elaraai/e3-ui 1.0.86 → 1.0.87

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

@@ -0,0 +1,4028 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { ArrayType, AsyncFunctionType, BooleanType, DateTimeType, DictType, FloatType, FunctionType, NullType, OptionType, SetType, StringType, StructType, VariantType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
+import { type UIElement, type RowSourceInput } from "@elaraai/east-ui";
+import { RowSourceType, SliceBindType, type SliceAffordanceLiteral, type RecordSliceChromeOptions } from "@elaraai/east-ui/internal";
+import { RecordBindingType } from "../bind/record.js";
+import * as T from "./types.js";
+import { ScheduleClockType } from "../schedule/types.js";
+import { rosterCoverage, rosterWeekHours } from "./coverage.js";
+import { rosterCheck, rosterRest } from "./rules.js";
+import { rosterPeople } from "./people.js";
+import { RosterPatchType, rosterActivitiesTab, rosterLibraryTab, rosterPatch, rosterPeopleTab, type RosterLibraryTab } from "./library.js";
+/** Roster's layout: group shifts, or people across the week. */
+export declare const RosterLayoutType: VariantType<{
+    readonly shifts: NullType;
+    readonly people: NullType;
+}>;
+/** Roster's displayed period. People always shows the whole week. */
+export declare const RosterPeriodType: VariantType<{
+    readonly day: NullType;
+    readonly week: NullType;
+}>;
+/** A declared built-in or author-defined library tab. */
+export declare const RosterLibraryTabType: VariantType<{
+    readonly people: NullType;
+    readonly activities: NullType;
+    readonly tab: StructType<{
+        readonly name: StringType;
+        readonly icon: OptionType<StringType>;
+        readonly cards: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly meta: OptionType<StringType>;
+            readonly group: OptionType<StringType>;
+            readonly patch: OptionType<StructType<{
+                readonly position: OptionType<StringType>;
+                readonly activity: OptionType<OptionType<StringType>>;
+                readonly offset: OptionType<FloatType>;
+                readonly overtime: OptionType<FloatType>;
+                readonly agreed: OptionType<OptionType<BooleanType>>;
+            }>>;
+        }>>;
+    }>;
+}>;
+/** A custom assignment form receives the value and an update callback, as Plan does. */
+export declare const RosterAssignmentFormType: FunctionType<[StructType<{
+    readonly slot: StructType<{
+        readonly day: import("@elaraai/east").IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly who: VariantType<{
+        readonly person: StringType;
+        readonly request: StringType;
+    }>;
+    readonly position: StringType;
+    readonly activity: OptionType<StringType>;
+    readonly offset: FloatType;
+    readonly overtime: FloatType;
+    readonly agreed: OptionType<BooleanType>;
+}>, FunctionType<[StructType<{
+    readonly slot: StructType<{
+        readonly day: import("@elaraai/east").IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>;
+    readonly who: VariantType<{
+        readonly person: StringType;
+        readonly request: StringType;
+    }>;
+    readonly position: StringType;
+    readonly activity: OptionType<StringType>;
+    readonly offset: FloatType;
+    readonly overtime: FloatType;
+    readonly agreed: OptionType<BooleanType>;
+}>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>;
+/** A custom requirement form receives the value and an update callback. */
+export declare const RosterRequirementFormType: FunctionType<[StructType<{
+    readonly positions: import("@elaraai/east").IntegerType;
+    readonly hours: DictType<StringType, FloatType>;
+}>, FunctionType<[StructType<{
+    readonly positions: import("@elaraai/east").IntegerType;
+    readonly hours: DictType<StringType, FloatType>;
+}>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>;
+/** Optional forms; absent forms use the shared FieldForm inspector. */
+export declare const RosterInspectorType: StructType<{
+    readonly assignment: OptionType<FunctionType<[StructType<{
+        readonly slot: StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>;
+        readonly who: VariantType<{
+            readonly person: StringType;
+            readonly request: StringType;
+        }>;
+        readonly position: StringType;
+        readonly activity: OptionType<StringType>;
+        readonly offset: FloatType;
+        readonly overtime: FloatType;
+        readonly agreed: OptionType<BooleanType>;
+    }>, FunctionType<[StructType<{
+        readonly slot: StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>;
+        readonly who: VariantType<{
+            readonly person: StringType;
+            readonly request: StringType;
+        }>;
+        readonly position: StringType;
+        readonly activity: OptionType<StringType>;
+        readonly offset: FloatType;
+        readonly overtime: FloatType;
+        readonly agreed: OptionType<BooleanType>;
+    }>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly requirement: OptionType<FunctionType<[StructType<{
+        readonly positions: import("@elaraai/east").IntegerType;
+        readonly hours: DictType<StringType, FloatType>;
+    }>, FunctionType<[StructType<{
+        readonly positions: import("@elaraai/east").IntegerType;
+        readonly hours: DictType<StringType, FloatType>;
+    }>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+}>;
+/** Record interface needed by the tag; Record.onApply checks the bound patch door. */
+export type RosterWeeksHandle = ExprType<StructType<{
+    read: FunctionType<[], T.RosterWeeksType>;
+    binding: RecordBindingType;
+}>>;
+/** Optional paged history, over the same weeks record. */
+export declare const RosterWindowType: StructType<{
+    readonly id: StringType;
+    readonly page: FunctionType<[import("@elaraai/east").IntegerType, import("@elaraai/east").IntegerType], OptionType<DictType<DateTimeType, StructType<{
+        readonly status: VariantType<{
+            readonly draft: NullType;
+            readonly published: StructType<{
+                readonly at: DateTimeType;
+            }>;
+        }>;
+        readonly assignments: DictType<StringType, StructType<{
+            readonly slot: StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly offset: FloatType;
+            readonly overtime: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+        }>>;
+        readonly requirements: DictType<StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>>;
+        readonly dismissed: SetType<StringType>;
+    }>>>>;
+    readonly total: FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+    readonly seek: OptionType<FunctionType<[VariantType<{
+        readonly key: StringType;
+        readonly prefix: StringType;
+        readonly fields: StructType<{
+            readonly values: ArrayType<StringType>;
+            readonly prefix: OptionType<StringType>;
+        }>;
+        readonly range: StructType<{
+            readonly from: ArrayType<StringType>;
+            readonly to: ArrayType<StringType>;
+        }>;
+    }>], OptionType<StructType<{
+        readonly found: BooleanType;
+        readonly row: import("@elaraai/east").IntegerType;
+        readonly count: import("@elaraai/east").IntegerType;
+    }>>>>;
+    readonly revision: FunctionType<[], OptionType<StringType>>;
+    readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+}>;
+/** The closed renderer payload. BuilderFrame is internal to the renderer. */
+export declare const RosterPayloadType: StructType<{
+    readonly sourceId: StringType;
+    readonly read: FunctionType<[], DictType<DateTimeType, StructType<{
+        readonly status: VariantType<{
+            readonly draft: NullType;
+            readonly published: StructType<{
+                readonly at: DateTimeType;
+            }>;
+        }>;
+        readonly assignments: DictType<StringType, StructType<{
+            readonly slot: StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly offset: FloatType;
+            readonly overtime: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+        }>>;
+        readonly requirements: DictType<StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>>;
+        readonly dismissed: SetType<StringType>;
+    }>>>;
+    readonly apply: AsyncFunctionType<[StructType<{
+        readonly requestId: StringType;
+        readonly base: VariantType<{
+            revision: StringType;
+            snapshot: DictType<DateTimeType, StructType<{
+                readonly status: VariantType<{
+                    readonly draft: NullType;
+                    readonly published: StructType<{
+                        readonly at: DateTimeType;
+                    }>;
+                }>;
+                readonly assignments: DictType<StringType, StructType<{
+                    readonly slot: StructType<{
+                        readonly day: import("@elaraai/east").IntegerType;
+                        readonly group: StringType;
+                        readonly shift: StringType;
+                    }>;
+                    readonly who: VariantType<{
+                        readonly person: StringType;
+                        readonly request: StringType;
+                    }>;
+                    readonly position: StringType;
+                    readonly activity: OptionType<StringType>;
+                    readonly offset: FloatType;
+                    readonly overtime: FloatType;
+                    readonly agreed: OptionType<BooleanType>;
+                }>>;
+                readonly requirements: DictType<StructType<{
+                    readonly day: import("@elaraai/east").IntegerType;
+                    readonly group: StringType;
+                    readonly shift: StringType;
+                }>, StructType<{
+                    readonly positions: import("@elaraai/east").IntegerType;
+                    readonly hours: DictType<StringType, FloatType>;
+                }>>;
+                readonly dismissed: SetType<StringType>;
+            }>>;
+        }>;
+        readonly label: StringType;
+        readonly changes: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly patch: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: OptionType<StructType<{
+                        readonly status: VariantType<{
+                            readonly draft: NullType;
+                            readonly published: StructType<{
+                                readonly at: DateTimeType;
+                            }>;
+                        }>;
+                        readonly assignments: DictType<StringType, StructType<{
+                            readonly slot: StructType<{
+                                readonly day: import("@elaraai/east").IntegerType;
+                                readonly group: StringType;
+                                readonly shift: StringType;
+                            }>;
+                            readonly who: VariantType<{
+                                readonly person: StringType;
+                                readonly request: StringType;
+                            }>;
+                            readonly position: StringType;
+                            readonly activity: OptionType<StringType>;
+                            readonly offset: FloatType;
+                            readonly overtime: FloatType;
+                            readonly agreed: OptionType<BooleanType>;
+                        }>>;
+                        readonly requirements: DictType<StructType<{
+                            readonly day: import("@elaraai/east").IntegerType;
+                            readonly group: StringType;
+                            readonly shift: StringType;
+                        }>, StructType<{
+                            readonly positions: import("@elaraai/east").IntegerType;
+                            readonly hours: DictType<StringType, FloatType>;
+                        }>>;
+                        readonly dismissed: SetType<StringType>;
+                    }>>;
+                    after: OptionType<StructType<{
+                        readonly status: VariantType<{
+                            readonly draft: NullType;
+                            readonly published: StructType<{
+                                readonly at: DateTimeType;
+                            }>;
+                        }>;
+                        readonly assignments: DictType<StringType, StructType<{
+                            readonly slot: StructType<{
+                                readonly day: import("@elaraai/east").IntegerType;
+                                readonly group: StringType;
+                                readonly shift: StringType;
+                            }>;
+                            readonly who: VariantType<{
+                                readonly person: StringType;
+                                readonly request: StringType;
+                            }>;
+                            readonly position: StringType;
+                            readonly activity: OptionType<StringType>;
+                            readonly offset: FloatType;
+                            readonly overtime: FloatType;
+                            readonly agreed: OptionType<BooleanType>;
+                        }>>;
+                        readonly requirements: DictType<StructType<{
+                            readonly day: import("@elaraai/east").IntegerType;
+                            readonly group: StringType;
+                            readonly shift: StringType;
+                        }>, StructType<{
+                            readonly positions: import("@elaraai/east").IntegerType;
+                            readonly hours: DictType<StringType, FloatType>;
+                        }>>;
+                        readonly dismissed: SetType<StringType>;
+                    }>>;
+                }>;
+                patch: VariantType<{
+                    none: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: NullType;
+                            after: NullType;
+                        }>;
+                    }>;
+                    some: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StructType<{
+                                readonly status: VariantType<{
+                                    readonly draft: NullType;
+                                    readonly published: StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                }>;
+                                readonly assignments: DictType<StringType, StructType<{
+                                    readonly slot: StructType<{
+                                        readonly day: import("@elaraai/east").IntegerType;
+                                        readonly group: StringType;
+                                        readonly shift: StringType;
+                                    }>;
+                                    readonly who: VariantType<{
+                                        readonly person: StringType;
+                                        readonly request: StringType;
+                                    }>;
+                                    readonly position: StringType;
+                                    readonly activity: OptionType<StringType>;
+                                    readonly offset: FloatType;
+                                    readonly overtime: FloatType;
+                                    readonly agreed: OptionType<BooleanType>;
+                                }>>;
+                                readonly requirements: DictType<StructType<{
+                                    readonly day: import("@elaraai/east").IntegerType;
+                                    readonly group: StringType;
+                                    readonly shift: StringType;
+                                }>, StructType<{
+                                    readonly positions: import("@elaraai/east").IntegerType;
+                                    readonly hours: DictType<StringType, FloatType>;
+                                }>>;
+                                readonly dismissed: SetType<StringType>;
+                            }>;
+                            after: StructType<{
+                                readonly status: VariantType<{
+                                    readonly draft: NullType;
+                                    readonly published: StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                }>;
+                                readonly assignments: DictType<StringType, StructType<{
+                                    readonly slot: StructType<{
+                                        readonly day: import("@elaraai/east").IntegerType;
+                                        readonly group: StringType;
+                                        readonly shift: StringType;
+                                    }>;
+                                    readonly who: VariantType<{
+                                        readonly person: StringType;
+                                        readonly request: StringType;
+                                    }>;
+                                    readonly position: StringType;
+                                    readonly activity: OptionType<StringType>;
+                                    readonly offset: FloatType;
+                                    readonly overtime: FloatType;
+                                    readonly agreed: OptionType<BooleanType>;
+                                }>>;
+                                readonly requirements: DictType<StructType<{
+                                    readonly day: import("@elaraai/east").IntegerType;
+                                    readonly group: StringType;
+                                    readonly shift: StringType;
+                                }>, StructType<{
+                                    readonly positions: import("@elaraai/east").IntegerType;
+                                    readonly hours: DictType<StringType, FloatType>;
+                                }>>;
+                                readonly dismissed: SetType<StringType>;
+                            }>;
+                        }>;
+                        patch: StructType<{
+                            readonly status: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: VariantType<{
+                                        readonly draft: NullType;
+                                        readonly published: StructType<{
+                                            readonly at: DateTimeType;
+                                        }>;
+                                    }>;
+                                    after: VariantType<{
+                                        readonly draft: NullType;
+                                        readonly published: StructType<{
+                                            readonly at: DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                patch: VariantType<{
+                                    readonly draft: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    readonly published: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StructType<{
+                                                readonly at: DateTimeType;
+                                            }>;
+                                            after: StructType<{
+                                                readonly at: DateTimeType;
+                                            }>;
+                                        }>;
+                                        patch: StructType<{
+                                            readonly at: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: DateTimeType;
+                                                    after: DateTimeType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly assignments: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DictType<StringType, StructType<{
+                                        readonly slot: StructType<{
+                                            readonly day: import("@elaraai/east").IntegerType;
+                                            readonly group: StringType;
+                                            readonly shift: StringType;
+                                        }>;
+                                        readonly who: VariantType<{
+                                            readonly person: StringType;
+                                            readonly request: StringType;
+                                        }>;
+                                        readonly position: StringType;
+                                        readonly activity: OptionType<StringType>;
+                                        readonly offset: FloatType;
+                                        readonly overtime: FloatType;
+                                        readonly agreed: OptionType<BooleanType>;
+                                    }>>;
+                                    after: DictType<StringType, StructType<{
+                                        readonly slot: StructType<{
+                                            readonly day: import("@elaraai/east").IntegerType;
+                                            readonly group: StringType;
+                                            readonly shift: StringType;
+                                        }>;
+                                        readonly who: VariantType<{
+                                            readonly person: StringType;
+                                            readonly request: StringType;
+                                        }>;
+                                        readonly position: StringType;
+                                        readonly activity: OptionType<StringType>;
+                                        readonly offset: FloatType;
+                                        readonly overtime: FloatType;
+                                        readonly agreed: OptionType<BooleanType>;
+                                    }>>;
+                                }>;
+                                patch: DictType<StringType, VariantType<{
+                                    delete: StructType<{
+                                        readonly slot: StructType<{
+                                            readonly day: import("@elaraai/east").IntegerType;
+                                            readonly group: StringType;
+                                            readonly shift: StringType;
+                                        }>;
+                                        readonly who: VariantType<{
+                                            readonly person: StringType;
+                                            readonly request: StringType;
+                                        }>;
+                                        readonly position: StringType;
+                                        readonly activity: OptionType<StringType>;
+                                        readonly offset: FloatType;
+                                        readonly overtime: FloatType;
+                                        readonly agreed: OptionType<BooleanType>;
+                                    }>;
+                                    insert: StructType<{
+                                        readonly slot: StructType<{
+                                            readonly day: import("@elaraai/east").IntegerType;
+                                            readonly group: StringType;
+                                            readonly shift: StringType;
+                                        }>;
+                                        readonly who: VariantType<{
+                                            readonly person: StringType;
+                                            readonly request: StringType;
+                                        }>;
+                                        readonly position: StringType;
+                                        readonly activity: OptionType<StringType>;
+                                        readonly offset: FloatType;
+                                        readonly overtime: FloatType;
+                                        readonly agreed: OptionType<BooleanType>;
+                                    }>;
+                                    update: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StructType<{
+                                                readonly slot: StructType<{
+                                                    readonly day: import("@elaraai/east").IntegerType;
+                                                    readonly group: StringType;
+                                                    readonly shift: StringType;
+                                                }>;
+                                                readonly who: VariantType<{
+                                                    readonly person: StringType;
+                                                    readonly request: StringType;
+                                                }>;
+                                                readonly position: StringType;
+                                                readonly activity: OptionType<StringType>;
+                                                readonly offset: FloatType;
+                                                readonly overtime: FloatType;
+                                                readonly agreed: OptionType<BooleanType>;
+                                            }>;
+                                            after: StructType<{
+                                                readonly slot: StructType<{
+                                                    readonly day: import("@elaraai/east").IntegerType;
+                                                    readonly group: StringType;
+                                                    readonly shift: StringType;
+                                                }>;
+                                                readonly who: VariantType<{
+                                                    readonly person: StringType;
+                                                    readonly request: StringType;
+                                                }>;
+                                                readonly position: StringType;
+                                                readonly activity: OptionType<StringType>;
+                                                readonly offset: FloatType;
+                                                readonly overtime: FloatType;
+                                                readonly agreed: OptionType<BooleanType>;
+                                            }>;
+                                        }>;
+                                        patch: StructType<{
+                                            readonly slot: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StructType<{
+                                                        readonly day: import("@elaraai/east").IntegerType;
+                                                        readonly group: StringType;
+                                                        readonly shift: StringType;
+                                                    }>;
+                                                    after: StructType<{
+                                                        readonly day: import("@elaraai/east").IntegerType;
+                                                        readonly group: StringType;
+                                                        readonly shift: StringType;
+                                                    }>;
+                                                }>;
+                                                patch: StructType<{
+                                                    readonly day: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: import("@elaraai/east").IntegerType;
+                                                            after: import("@elaraai/east").IntegerType;
+                                                        }>;
+                                                    }>;
+                                                    readonly group: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                    readonly shift: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                            readonly who: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: VariantType<{
+                                                        readonly person: StringType;
+                                                        readonly request: StringType;
+                                                    }>;
+                                                    after: VariantType<{
+                                                        readonly person: StringType;
+                                                        readonly request: StringType;
+                                                    }>;
+                                                }>;
+                                                patch: VariantType<{
+                                                    readonly person: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                    readonly request: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                            readonly position: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                            readonly activity: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: OptionType<StringType>;
+                                                    after: OptionType<StringType>;
+                                                }>;
+                                                patch: VariantType<{
+                                                    none: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    some: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                            readonly offset: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: FloatType;
+                                                    after: FloatType;
+                                                }>;
+                                            }>;
+                                            readonly overtime: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: FloatType;
+                                                    after: FloatType;
+                                                }>;
+                                            }>;
+                                            readonly agreed: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: OptionType<BooleanType>;
+                                                    after: OptionType<BooleanType>;
+                                                }>;
+                                                patch: VariantType<{
+                                                    none: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    some: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: BooleanType;
+                                                            after: BooleanType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>;
+                            readonly requirements: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DictType<StructType<{
+                                        readonly day: import("@elaraai/east").IntegerType;
+                                        readonly group: StringType;
+                                        readonly shift: StringType;
+                                    }>, StructType<{
+                                        readonly positions: import("@elaraai/east").IntegerType;
+                                        readonly hours: DictType<StringType, FloatType>;
+                                    }>>;
+                                    after: DictType<StructType<{
+                                        readonly day: import("@elaraai/east").IntegerType;
+                                        readonly group: StringType;
+                                        readonly shift: StringType;
+                                    }>, StructType<{
+                                        readonly positions: import("@elaraai/east").IntegerType;
+                                        readonly hours: DictType<StringType, FloatType>;
+                                    }>>;
+                                }>;
+                                patch: DictType<StructType<{
+                                    readonly day: import("@elaraai/east").IntegerType;
+                                    readonly group: StringType;
+                                    readonly shift: StringType;
+                                }>, VariantType<{
+                                    delete: StructType<{
+                                        readonly positions: import("@elaraai/east").IntegerType;
+                                        readonly hours: DictType<StringType, FloatType>;
+                                    }>;
+                                    insert: StructType<{
+                                        readonly positions: import("@elaraai/east").IntegerType;
+                                        readonly hours: DictType<StringType, FloatType>;
+                                    }>;
+                                    update: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StructType<{
+                                                readonly positions: import("@elaraai/east").IntegerType;
+                                                readonly hours: DictType<StringType, FloatType>;
+                                            }>;
+                                            after: StructType<{
+                                                readonly positions: import("@elaraai/east").IntegerType;
+                                                readonly hours: DictType<StringType, FloatType>;
+                                            }>;
+                                        }>;
+                                        patch: StructType<{
+                                            readonly positions: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: import("@elaraai/east").IntegerType;
+                                                    after: import("@elaraai/east").IntegerType;
+                                                }>;
+                                            }>;
+                                            readonly hours: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: DictType<StringType, FloatType>;
+                                                    after: DictType<StringType, FloatType>;
+                                                }>;
+                                                patch: DictType<StringType, VariantType<{
+                                                    delete: FloatType;
+                                                    insert: FloatType;
+                                                    update: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: FloatType;
+                                                            after: FloatType;
+                                                        }>;
+                                                    }>;
+                                                }>>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>;
+                            readonly dismissed: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: SetType<StringType>;
+                                    after: SetType<StringType>;
+                                }>;
+                                patch: DictType<StringType, VariantType<{
+                                    delete: NullType;
+                                    insert: NullType;
+                                }>>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+            readonly place: OptionType<VariantType<{
+                readonly ordered: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                    readonly before: StringType;
+                    readonly after: StringType;
+                }>;
+                readonly keyOrder: NullType;
+            }>>;
+        }>>;
+    }>], VariantType<{
+        readonly applied: StructType<{
+            readonly revision: OptionType<StringType>;
+        }>;
+        readonly rejected: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<import("@elaraai/east").IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+        readonly conflict: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<import("@elaraai/east").IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+    }>>;
+    readonly window: OptionType<StructType<{
+        readonly id: StringType;
+        readonly page: FunctionType<[import("@elaraai/east").IntegerType, import("@elaraai/east").IntegerType], OptionType<DictType<DateTimeType, StructType<{
+            readonly status: VariantType<{
+                readonly draft: NullType;
+                readonly published: StructType<{
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+            readonly assignments: DictType<StringType, StructType<{
+                readonly slot: StructType<{
+                    readonly day: import("@elaraai/east").IntegerType;
+                    readonly group: StringType;
+                    readonly shift: StringType;
+                }>;
+                readonly who: VariantType<{
+                    readonly person: StringType;
+                    readonly request: StringType;
+                }>;
+                readonly position: StringType;
+                readonly activity: OptionType<StringType>;
+                readonly offset: FloatType;
+                readonly overtime: FloatType;
+                readonly agreed: OptionType<BooleanType>;
+            }>>;
+            readonly requirements: DictType<StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>, StructType<{
+                readonly positions: import("@elaraai/east").IntegerType;
+                readonly hours: DictType<StringType, FloatType>;
+            }>>;
+            readonly dismissed: SetType<StringType>;
+        }>>>>;
+        readonly total: FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+        readonly seek: OptionType<FunctionType<[VariantType<{
+            readonly key: StringType;
+            readonly prefix: StringType;
+            readonly fields: StructType<{
+                readonly values: ArrayType<StringType>;
+                readonly prefix: OptionType<StringType>;
+            }>;
+            readonly range: StructType<{
+                readonly from: ArrayType<StringType>;
+                readonly to: ArrayType<StringType>;
+            }>;
+        }>], OptionType<StructType<{
+            readonly found: BooleanType;
+            readonly row: import("@elaraai/east").IntegerType;
+            readonly count: import("@elaraai/east").IntegerType;
+        }>>>>;
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+    }>>;
+    readonly people: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly group: StringType;
+        readonly position: StringType;
+        readonly skills: SetType<StringType>;
+        readonly contract: FloatType;
+        readonly agency: BooleanType;
+        readonly trainer: BooleanType;
+        readonly trainee: BooleanType;
+        readonly usual: OptionType<StringType>;
+    }>>;
+    readonly visiblePeople: OptionType<SetType<StringType>>;
+    readonly groups: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly skills: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+        }>>;
+    }>>;
+    readonly duties: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly code: StringType;
+    }>>;
+    readonly shifts: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly code: StringType;
+        readonly start: StructType<{
+            readonly hour: import("@elaraai/east").IntegerType;
+            readonly minute: import("@elaraai/east").IntegerType;
+        }>;
+        readonly hours: FloatType;
+    }>>;
+    readonly positions: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly code: StringType;
+        readonly lead: BooleanType;
+    }>>;
+    readonly agencies: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+    }>>;
+    readonly rules: StructType<{
+        readonly rest: FloatType;
+        readonly lead: BooleanType;
+        readonly trainer: BooleanType;
+        readonly skill: BooleanType;
+        readonly agree: BooleanType;
+    }>;
+    readonly costs: OptionType<StructType<{
+        readonly currency: StringType;
+        readonly rates: StructType<{
+            readonly permanent: FloatType;
+            readonly overtime: FloatType;
+            readonly agency: FloatType;
+        }>;
+        readonly budget: OptionType<FloatType>;
+    }>>;
+    readonly forecast: DictType<DateTimeType, DictType<StructType<{
+        readonly day: import("@elaraai/east").IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>, StructType<{
+        readonly positions: import("@elaraai/east").IntegerType;
+        readonly hours: DictType<StringType, FloatType>;
+    }>>>;
+    readonly proposals: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly week: DateTimeType;
+        readonly slot: StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>;
+        readonly person: StringType;
+        readonly reason: StringType;
+    }>>;
+    readonly check: OptionType<FunctionType<[StructType<{
+        readonly start: DateTimeType;
+        readonly week: StructType<{
+            readonly status: VariantType<{
+                readonly draft: NullType;
+                readonly published: StructType<{
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+            readonly assignments: DictType<StringType, StructType<{
+                readonly slot: StructType<{
+                    readonly day: import("@elaraai/east").IntegerType;
+                    readonly group: StringType;
+                    readonly shift: StringType;
+                }>;
+                readonly who: VariantType<{
+                    readonly person: StringType;
+                    readonly request: StringType;
+                }>;
+                readonly position: StringType;
+                readonly activity: OptionType<StringType>;
+                readonly offset: FloatType;
+                readonly overtime: FloatType;
+                readonly agreed: OptionType<BooleanType>;
+            }>>;
+            readonly requirements: DictType<StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>, StructType<{
+                readonly positions: import("@elaraai/east").IntegerType;
+                readonly hours: DictType<StringType, FloatType>;
+            }>>;
+            readonly dismissed: SetType<StringType>;
+        }>;
+        readonly context: StructType<{
+            readonly people: DictType<StringType, StructType<{
+                readonly key: StringType;
+                readonly name: StringType;
+                readonly group: StringType;
+                readonly position: StringType;
+                readonly skills: SetType<StringType>;
+                readonly contract: FloatType;
+                readonly agency: BooleanType;
+                readonly trainer: BooleanType;
+                readonly trainee: BooleanType;
+                readonly usual: OptionType<StringType>;
+            }>>;
+            readonly groups: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly skills: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly label: StringType;
+                    readonly code: StringType;
+                }>>;
+            }>>;
+            readonly duties: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly code: StringType;
+            }>>;
+            readonly shifts: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly code: StringType;
+                readonly start: StructType<{
+                    readonly hour: import("@elaraai/east").IntegerType;
+                    readonly minute: import("@elaraai/east").IntegerType;
+                }>;
+                readonly hours: FloatType;
+            }>>;
+            readonly positions: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly code: StringType;
+                readonly lead: BooleanType;
+            }>>;
+            readonly agencies: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly name: StringType;
+            }>>;
+            readonly rules: StructType<{
+                readonly rest: FloatType;
+                readonly lead: BooleanType;
+                readonly trainer: BooleanType;
+                readonly skill: BooleanType;
+                readonly agree: BooleanType;
+            }>;
+            readonly costs: OptionType<StructType<{
+                readonly currency: StringType;
+                readonly rates: StructType<{
+                    readonly permanent: FloatType;
+                    readonly overtime: FloatType;
+                    readonly agency: FloatType;
+                }>;
+                readonly budget: OptionType<FloatType>;
+            }>>;
+        }>;
+        readonly coverage: DictType<StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly filled: import("@elaraai/east").IntegerType;
+            readonly open: import("@elaraai/east").IntegerType;
+            readonly people: import("@elaraai/east").IntegerType;
+            readonly hours: StructType<{
+                readonly permanent: FloatType;
+                readonly agency: FloatType;
+                readonly overtime: FloatType;
+                readonly requested: FloatType;
+                readonly needed: FloatType;
+                readonly rostered: FloatType;
+            }>;
+            readonly lines: ArrayType<StructType<{
+                readonly skill: StringType;
+                readonly needed: FloatType;
+                readonly holders: OptionType<import("@elaraai/east").IntegerType>;
+                readonly capacity: OptionType<FloatType>;
+                readonly gap: FloatType;
+                readonly assigned: FloatType;
+            }>>;
+            readonly cost: FloatType;
+            readonly lead: BooleanType;
+            readonly trainer: BooleanType;
+        }>>;
+    }>], ArrayType<StructType<{
+        readonly kind: VariantType<{
+            readonly breach: NullType;
+            readonly gap: NullType;
+            readonly agree: NullType;
+            readonly proposal: NullType;
+        }>;
+        readonly tone: VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly title: StringType;
+        readonly detail: StringType;
+        readonly slot: OptionType<StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>>;
+        readonly assignment: OptionType<StringType>;
+        readonly flag: OptionType<StringType>;
+        readonly fix: OptionType<VariantType<{
+            readonly request: StringType;
+            readonly agree: NullType;
+            readonly accept: StringType;
+            readonly move: StringType;
+            readonly start: FloatType;
+            readonly find: VariantType<{
+                readonly leads: NullType;
+                readonly trainers: NullType;
+                readonly skill: StringType;
+            }>;
+        }>>;
+    }>>>>;
+    readonly library: ArrayType<VariantType<{
+        readonly people: NullType;
+        readonly activities: NullType;
+        readonly tab: StructType<{
+            readonly name: StringType;
+            readonly icon: OptionType<StringType>;
+            readonly cards: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly meta: OptionType<StringType>;
+                readonly group: OptionType<StringType>;
+                readonly patch: OptionType<StructType<{
+                    readonly position: OptionType<StringType>;
+                    readonly activity: OptionType<OptionType<StringType>>;
+                    readonly offset: OptionType<FloatType>;
+                    readonly overtime: OptionType<FloatType>;
+                    readonly agreed: OptionType<OptionType<BooleanType>>;
+                }>>;
+            }>>;
+        }>;
+    }>>;
+    readonly inspector: OptionType<StructType<{
+        readonly assignment: OptionType<FunctionType<[StructType<{
+            readonly slot: StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly offset: FloatType;
+            readonly overtime: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+        }>, FunctionType<[StructType<{
+            readonly slot: StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly offset: FloatType;
+            readonly overtime: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+        }>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+        readonly requirement: OptionType<FunctionType<[StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>, FunctionType<[StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    }>>;
+    readonly slice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: StringType;
+            readonly read: FunctionType<[], StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: import("@elaraai/east").IntegerType;
+                        readonly to: import("@elaraai/east").IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: 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: SetType<StringType>;
+                            readonly notIn: 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: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: 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: SetType<StringType>;
+                                readonly notIn: 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: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<SetType<StringType>>;
+                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly resolution: OptionType<VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>>;
+            readonly write: FunctionType<[StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: import("@elaraai/east").IntegerType;
+                        readonly to: import("@elaraai/east").IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: 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: SetType<StringType>;
+                            readonly notIn: 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: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: 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: SetType<StringType>;
+                                readonly notIn: 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: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<SetType<StringType>>;
+                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly resolution: OptionType<VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>], NullType>;
+            readonly setRange: FunctionType<[OptionType<VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: DateTimeType;
+                    readonly to: DateTimeType;
+                }>;
+                readonly datetimePreset: VariantType<{
+                    readonly today: NullType;
+                    readonly last7d: NullType;
+                    readonly last30d: NullType;
+                    readonly last90d: NullType;
+                    readonly ytd: NullType;
+                }>;
+                readonly integer: StructType<{
+                    readonly from: import("@elaraai/east").IntegerType;
+                    readonly to: import("@elaraai/east").IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: FloatType;
+                    readonly to: 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: SetType<StringType>;
+                        readonly notIn: 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: import("@elaraai/east").IntegerType;
+                        readonly neq: import("@elaraai/east").IntegerType;
+                        readonly lt: import("@elaraai/east").IntegerType;
+                        readonly lte: import("@elaraai/east").IntegerType;
+                        readonly gt: import("@elaraai/east").IntegerType;
+                        readonly gte: import("@elaraai/east").IntegerType;
+                        readonly in: SetType<import("@elaraai/east").IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly removeFilter: FunctionType<[import("@elaraai/east").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: SetType<StringType>;
+                            readonly notIn: 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: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], 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: SetType<StringType>;
+                            readonly notIn: 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: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], NullType>;
+            readonly removeCohort: FunctionType<[StringType], NullType>;
+            readonly toggleCohort: FunctionType<[StringType], NullType>;
+            readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+            }>>], NullType>;
+            readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+            readonly setVisible: FunctionType<[OptionType<SetType<StringType>>], NullType>;
+            readonly select: FunctionType<[OptionType<import("@elaraai/east").IntegerType>], NullType>;
+            readonly isActive: FunctionType<[], BooleanType>;
+            readonly activeCount: FunctionType<[], import("@elaraai/east").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: 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<[], import("@elaraai/east").IntegerType>;
+            readonly resultCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+            readonly groups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: import("@elaraai/east").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: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<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, import("@elaraai/east").IntegerType>>;
+            readonly toggleFilter: FunctionType<[VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: SetType<StringType>;
+                        readonly notIn: 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: import("@elaraai/east").IntegerType;
+                        readonly neq: import("@elaraai/east").IntegerType;
+                        readonly lt: import("@elaraai/east").IntegerType;
+                        readonly lte: import("@elaraai/east").IntegerType;
+                        readonly gt: import("@elaraai/east").IntegerType;
+                        readonly gte: import("@elaraai/east").IntegerType;
+                        readonly in: SetType<import("@elaraai/east").IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: import("@elaraai/east").IntegerType;
+                readonly color: StringType;
+            }>>>;
+            readonly setResolution: FunctionType<[OptionType<VariantType<{
+                readonly auto: NullType;
+                readonly hour: NullType;
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
+            }>>], NullType>;
+        }>;
+        readonly affordances: ArrayType<VariantType<{
+            readonly filter: NullType;
+            readonly search: NullType;
+            readonly breakdown: NullType;
+            readonly range: NullType;
+            readonly cohort: NullType;
+            readonly brush: NullType;
+            readonly presets: NullType;
+            readonly legend: NullType;
+            readonly resolution: NullType;
+            readonly summary: NullType;
+        }>>;
+    }>>;
+    readonly settings: StructType<{
+        readonly layout: VariantType<{
+            readonly shifts: NullType;
+            readonly people: NullType;
+        }>;
+        readonly period: VariantType<{
+            readonly day: NullType;
+            readonly week: NullType;
+        }>;
+        readonly date: OptionType<DateTimeType>;
+        readonly weekStart: VariantType<{
+            readonly monday: NullType;
+            readonly sunday: NullType;
+        }>;
+        readonly density: VariantType<{
+            readonly compact: NullType;
+            readonly comfortable: NullType;
+        }>;
+        readonly chipSkills: BooleanType;
+        readonly requirements: BooleanType;
+        readonly readOnly: BooleanType;
+    }>;
+    readonly id: OptionType<StringType>;
+    readonly recordSlice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: import("@elaraai/east").StringType;
+            readonly config: StructType<{
+                readonly fields: ArrayType<StructType<{
+                    readonly fieldId: import("@elaraai/east").StringType;
+                    readonly label: import("@elaraai/east").StringType;
+                    readonly kind: import("@elaraai/east").StringType;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly multiple: import("@elaraai/east").BooleanType;
+                    readonly set: import("@elaraai/east").BooleanType;
+                    readonly values: ArrayType<StructType<{
+                        readonly value: import("@elaraai/east").StringType;
+                        readonly label: import("@elaraai/east").StringType;
+                    }>>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: import("@elaraai/east").StringType;
+                            readonly compact: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: import("@elaraai/east").StringType;
+                        readonly time: import("@elaraai/east").StringType;
+                        readonly datetime: import("@elaraai/east").StringType;
+                    }>>;
+                }>>;
+                readonly indexes: ArrayType<StructType<{
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly fields: ArrayType<import("@elaraai/east").StringType>;
+                    readonly sets: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
+                    readonly structured: import("@elaraai/east").BooleanType;
+                    readonly interval: OptionType<StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                        readonly optional: import("@elaraai/east").BooleanType;
+                    }>>;
+                }>>;
+                readonly range: OptionType<import("@elaraai/east").StringType>;
+                readonly search: ArrayType<import("@elaraai/east").StringType>;
+                readonly presets: ArrayType<StructType<{
+                    readonly id: import("@elaraai/east").StringType;
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>;
+                }>>;
+            }>;
+            readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                    readonly values: ArrayType<import("@elaraai/east").StringType>;
+                    readonly range: StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                    }>;
+                    readonly prefix: import("@elaraai/east").StringType;
+                }>>;
+                readonly preset: OptionType<import("@elaraai/east").StringType>;
+                readonly resolution: OptionType<VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>>;
+            readonly write: import("@elaraai/east").FunctionType<[StructType<{
+                readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                    readonly values: ArrayType<import("@elaraai/east").StringType>;
+                    readonly range: StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                    }>;
+                    readonly prefix: import("@elaraai/east").StringType;
+                }>>;
+                readonly preset: OptionType<import("@elaraai/east").StringType>;
+                readonly resolution: OptionType<VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>], NullType>;
+            readonly choose: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, ArrayType<import("@elaraai/east").StringType>], NullType>;
+            readonly range: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+            readonly prefix: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+            readonly clear: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+            readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly count: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly countWhere: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                readonly range: StructType<{
+                    readonly from: import("@elaraai/east").StringType;
+                    readonly to: import("@elaraai/east").StringType;
+                }>;
+                readonly prefix: import("@elaraai/east").StringType;
+            }>>], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly total: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly domain: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<StructType<{
+                readonly from: import("@elaraai/east").StringType;
+                readonly to: import("@elaraai/east").StringType;
+            }>>>;
+            readonly values: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<StructType<{
+                readonly value: import("@elaraai/east").StringType;
+                readonly label: import("@elaraai/east").StringType;
+                readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                readonly selected: import("@elaraai/east").BooleanType;
+                readonly error: OptionType<import("@elaraai/east").StringType>;
+            }>>>;
+            readonly suggest: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], OptionType<ArrayType<StructType<{
+                readonly value: import("@elaraai/east").StringType;
+                readonly label: import("@elaraai/east").StringType;
+                readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                readonly selected: import("@elaraai/east").BooleanType;
+                readonly error: OptionType<import("@elaraai/east").StringType>;
+            }>>>>;
+            readonly replaces: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<import("@elaraai/east").StringType>>;
+            readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+            readonly setResolution: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
+                readonly auto: NullType;
+                readonly hour: NullType;
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
+            }>>], NullType>;
+            readonly retry: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly sourceId: import("@elaraai/east").StringType;
+            readonly readEntry: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<OptionType<import("@elaraai/east").BlobType>>>;
+            readonly contains: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                readonly range: StructType<{
+                    readonly from: import("@elaraai/east").StringType;
+                    readonly to: import("@elaraai/east").StringType;
+                }>;
+                readonly prefix: import("@elaraai/east").StringType;
+            }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
+        }>;
+        readonly affordances: ArrayType<VariantType<{
+            readonly fields: NullType;
+            readonly search: NullType;
+            readonly range: NullType;
+            readonly presets: NullType;
+            readonly resolution: NullType;
+            readonly brush: NullType;
+            readonly summary: NullType;
+        }>>;
+        readonly persist: OptionType<VariantType<{
+            readonly local: NullType;
+            readonly session: NullType;
+            readonly url: NullType;
+        }>>;
+    }>>;
+    readonly visibleSource: OptionType<RowSourceType<ArrayType<StringType>>>;
+}>;
+/** Carrier registered by e3-ui-components. */
+export declare const RosterComponent: import("@elaraai/east-ui").UIComponentDef<StructType<{
+    readonly sourceId: StringType;
+    readonly read: FunctionType<[], DictType<DateTimeType, StructType<{
+        readonly status: VariantType<{
+            readonly draft: NullType;
+            readonly published: StructType<{
+                readonly at: DateTimeType;
+            }>;
+        }>;
+        readonly assignments: DictType<StringType, StructType<{
+            readonly slot: StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly offset: FloatType;
+            readonly overtime: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+        }>>;
+        readonly requirements: DictType<StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>>;
+        readonly dismissed: SetType<StringType>;
+    }>>>;
+    readonly apply: AsyncFunctionType<[StructType<{
+        readonly requestId: StringType;
+        readonly base: VariantType<{
+            revision: StringType;
+            snapshot: DictType<DateTimeType, StructType<{
+                readonly status: VariantType<{
+                    readonly draft: NullType;
+                    readonly published: StructType<{
+                        readonly at: DateTimeType;
+                    }>;
+                }>;
+                readonly assignments: DictType<StringType, StructType<{
+                    readonly slot: StructType<{
+                        readonly day: import("@elaraai/east").IntegerType;
+                        readonly group: StringType;
+                        readonly shift: StringType;
+                    }>;
+                    readonly who: VariantType<{
+                        readonly person: StringType;
+                        readonly request: StringType;
+                    }>;
+                    readonly position: StringType;
+                    readonly activity: OptionType<StringType>;
+                    readonly offset: FloatType;
+                    readonly overtime: FloatType;
+                    readonly agreed: OptionType<BooleanType>;
+                }>>;
+                readonly requirements: DictType<StructType<{
+                    readonly day: import("@elaraai/east").IntegerType;
+                    readonly group: StringType;
+                    readonly shift: StringType;
+                }>, StructType<{
+                    readonly positions: import("@elaraai/east").IntegerType;
+                    readonly hours: DictType<StringType, FloatType>;
+                }>>;
+                readonly dismissed: SetType<StringType>;
+            }>>;
+        }>;
+        readonly label: StringType;
+        readonly changes: ArrayType<StructType<{
+            readonly id: StringType;
+            readonly patch: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: OptionType<StructType<{
+                        readonly status: VariantType<{
+                            readonly draft: NullType;
+                            readonly published: StructType<{
+                                readonly at: DateTimeType;
+                            }>;
+                        }>;
+                        readonly assignments: DictType<StringType, StructType<{
+                            readonly slot: StructType<{
+                                readonly day: import("@elaraai/east").IntegerType;
+                                readonly group: StringType;
+                                readonly shift: StringType;
+                            }>;
+                            readonly who: VariantType<{
+                                readonly person: StringType;
+                                readonly request: StringType;
+                            }>;
+                            readonly position: StringType;
+                            readonly activity: OptionType<StringType>;
+                            readonly offset: FloatType;
+                            readonly overtime: FloatType;
+                            readonly agreed: OptionType<BooleanType>;
+                        }>>;
+                        readonly requirements: DictType<StructType<{
+                            readonly day: import("@elaraai/east").IntegerType;
+                            readonly group: StringType;
+                            readonly shift: StringType;
+                        }>, StructType<{
+                            readonly positions: import("@elaraai/east").IntegerType;
+                            readonly hours: DictType<StringType, FloatType>;
+                        }>>;
+                        readonly dismissed: SetType<StringType>;
+                    }>>;
+                    after: OptionType<StructType<{
+                        readonly status: VariantType<{
+                            readonly draft: NullType;
+                            readonly published: StructType<{
+                                readonly at: DateTimeType;
+                            }>;
+                        }>;
+                        readonly assignments: DictType<StringType, StructType<{
+                            readonly slot: StructType<{
+                                readonly day: import("@elaraai/east").IntegerType;
+                                readonly group: StringType;
+                                readonly shift: StringType;
+                            }>;
+                            readonly who: VariantType<{
+                                readonly person: StringType;
+                                readonly request: StringType;
+                            }>;
+                            readonly position: StringType;
+                            readonly activity: OptionType<StringType>;
+                            readonly offset: FloatType;
+                            readonly overtime: FloatType;
+                            readonly agreed: OptionType<BooleanType>;
+                        }>>;
+                        readonly requirements: DictType<StructType<{
+                            readonly day: import("@elaraai/east").IntegerType;
+                            readonly group: StringType;
+                            readonly shift: StringType;
+                        }>, StructType<{
+                            readonly positions: import("@elaraai/east").IntegerType;
+                            readonly hours: DictType<StringType, FloatType>;
+                        }>>;
+                        readonly dismissed: SetType<StringType>;
+                    }>>;
+                }>;
+                patch: VariantType<{
+                    none: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: NullType;
+                            after: NullType;
+                        }>;
+                    }>;
+                    some: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StructType<{
+                                readonly status: VariantType<{
+                                    readonly draft: NullType;
+                                    readonly published: StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                }>;
+                                readonly assignments: DictType<StringType, StructType<{
+                                    readonly slot: StructType<{
+                                        readonly day: import("@elaraai/east").IntegerType;
+                                        readonly group: StringType;
+                                        readonly shift: StringType;
+                                    }>;
+                                    readonly who: VariantType<{
+                                        readonly person: StringType;
+                                        readonly request: StringType;
+                                    }>;
+                                    readonly position: StringType;
+                                    readonly activity: OptionType<StringType>;
+                                    readonly offset: FloatType;
+                                    readonly overtime: FloatType;
+                                    readonly agreed: OptionType<BooleanType>;
+                                }>>;
+                                readonly requirements: DictType<StructType<{
+                                    readonly day: import("@elaraai/east").IntegerType;
+                                    readonly group: StringType;
+                                    readonly shift: StringType;
+                                }>, StructType<{
+                                    readonly positions: import("@elaraai/east").IntegerType;
+                                    readonly hours: DictType<StringType, FloatType>;
+                                }>>;
+                                readonly dismissed: SetType<StringType>;
+                            }>;
+                            after: StructType<{
+                                readonly status: VariantType<{
+                                    readonly draft: NullType;
+                                    readonly published: StructType<{
+                                        readonly at: DateTimeType;
+                                    }>;
+                                }>;
+                                readonly assignments: DictType<StringType, StructType<{
+                                    readonly slot: StructType<{
+                                        readonly day: import("@elaraai/east").IntegerType;
+                                        readonly group: StringType;
+                                        readonly shift: StringType;
+                                    }>;
+                                    readonly who: VariantType<{
+                                        readonly person: StringType;
+                                        readonly request: StringType;
+                                    }>;
+                                    readonly position: StringType;
+                                    readonly activity: OptionType<StringType>;
+                                    readonly offset: FloatType;
+                                    readonly overtime: FloatType;
+                                    readonly agreed: OptionType<BooleanType>;
+                                }>>;
+                                readonly requirements: DictType<StructType<{
+                                    readonly day: import("@elaraai/east").IntegerType;
+                                    readonly group: StringType;
+                                    readonly shift: StringType;
+                                }>, StructType<{
+                                    readonly positions: import("@elaraai/east").IntegerType;
+                                    readonly hours: DictType<StringType, FloatType>;
+                                }>>;
+                                readonly dismissed: SetType<StringType>;
+                            }>;
+                        }>;
+                        patch: StructType<{
+                            readonly status: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: VariantType<{
+                                        readonly draft: NullType;
+                                        readonly published: StructType<{
+                                            readonly at: DateTimeType;
+                                        }>;
+                                    }>;
+                                    after: VariantType<{
+                                        readonly draft: NullType;
+                                        readonly published: StructType<{
+                                            readonly at: DateTimeType;
+                                        }>;
+                                    }>;
+                                }>;
+                                patch: VariantType<{
+                                    readonly draft: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: NullType;
+                                            after: NullType;
+                                        }>;
+                                    }>;
+                                    readonly published: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StructType<{
+                                                readonly at: DateTimeType;
+                                            }>;
+                                            after: StructType<{
+                                                readonly at: DateTimeType;
+                                            }>;
+                                        }>;
+                                        patch: StructType<{
+                                            readonly at: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: DateTimeType;
+                                                    after: DateTimeType;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly assignments: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DictType<StringType, StructType<{
+                                        readonly slot: StructType<{
+                                            readonly day: import("@elaraai/east").IntegerType;
+                                            readonly group: StringType;
+                                            readonly shift: StringType;
+                                        }>;
+                                        readonly who: VariantType<{
+                                            readonly person: StringType;
+                                            readonly request: StringType;
+                                        }>;
+                                        readonly position: StringType;
+                                        readonly activity: OptionType<StringType>;
+                                        readonly offset: FloatType;
+                                        readonly overtime: FloatType;
+                                        readonly agreed: OptionType<BooleanType>;
+                                    }>>;
+                                    after: DictType<StringType, StructType<{
+                                        readonly slot: StructType<{
+                                            readonly day: import("@elaraai/east").IntegerType;
+                                            readonly group: StringType;
+                                            readonly shift: StringType;
+                                        }>;
+                                        readonly who: VariantType<{
+                                            readonly person: StringType;
+                                            readonly request: StringType;
+                                        }>;
+                                        readonly position: StringType;
+                                        readonly activity: OptionType<StringType>;
+                                        readonly offset: FloatType;
+                                        readonly overtime: FloatType;
+                                        readonly agreed: OptionType<BooleanType>;
+                                    }>>;
+                                }>;
+                                patch: DictType<StringType, VariantType<{
+                                    delete: StructType<{
+                                        readonly slot: StructType<{
+                                            readonly day: import("@elaraai/east").IntegerType;
+                                            readonly group: StringType;
+                                            readonly shift: StringType;
+                                        }>;
+                                        readonly who: VariantType<{
+                                            readonly person: StringType;
+                                            readonly request: StringType;
+                                        }>;
+                                        readonly position: StringType;
+                                        readonly activity: OptionType<StringType>;
+                                        readonly offset: FloatType;
+                                        readonly overtime: FloatType;
+                                        readonly agreed: OptionType<BooleanType>;
+                                    }>;
+                                    insert: StructType<{
+                                        readonly slot: StructType<{
+                                            readonly day: import("@elaraai/east").IntegerType;
+                                            readonly group: StringType;
+                                            readonly shift: StringType;
+                                        }>;
+                                        readonly who: VariantType<{
+                                            readonly person: StringType;
+                                            readonly request: StringType;
+                                        }>;
+                                        readonly position: StringType;
+                                        readonly activity: OptionType<StringType>;
+                                        readonly offset: FloatType;
+                                        readonly overtime: FloatType;
+                                        readonly agreed: OptionType<BooleanType>;
+                                    }>;
+                                    update: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StructType<{
+                                                readonly slot: StructType<{
+                                                    readonly day: import("@elaraai/east").IntegerType;
+                                                    readonly group: StringType;
+                                                    readonly shift: StringType;
+                                                }>;
+                                                readonly who: VariantType<{
+                                                    readonly person: StringType;
+                                                    readonly request: StringType;
+                                                }>;
+                                                readonly position: StringType;
+                                                readonly activity: OptionType<StringType>;
+                                                readonly offset: FloatType;
+                                                readonly overtime: FloatType;
+                                                readonly agreed: OptionType<BooleanType>;
+                                            }>;
+                                            after: StructType<{
+                                                readonly slot: StructType<{
+                                                    readonly day: import("@elaraai/east").IntegerType;
+                                                    readonly group: StringType;
+                                                    readonly shift: StringType;
+                                                }>;
+                                                readonly who: VariantType<{
+                                                    readonly person: StringType;
+                                                    readonly request: StringType;
+                                                }>;
+                                                readonly position: StringType;
+                                                readonly activity: OptionType<StringType>;
+                                                readonly offset: FloatType;
+                                                readonly overtime: FloatType;
+                                                readonly agreed: OptionType<BooleanType>;
+                                            }>;
+                                        }>;
+                                        patch: StructType<{
+                                            readonly slot: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StructType<{
+                                                        readonly day: import("@elaraai/east").IntegerType;
+                                                        readonly group: StringType;
+                                                        readonly shift: StringType;
+                                                    }>;
+                                                    after: StructType<{
+                                                        readonly day: import("@elaraai/east").IntegerType;
+                                                        readonly group: StringType;
+                                                        readonly shift: StringType;
+                                                    }>;
+                                                }>;
+                                                patch: StructType<{
+                                                    readonly day: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: import("@elaraai/east").IntegerType;
+                                                            after: import("@elaraai/east").IntegerType;
+                                                        }>;
+                                                    }>;
+                                                    readonly group: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                    readonly shift: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                            readonly who: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: VariantType<{
+                                                        readonly person: StringType;
+                                                        readonly request: StringType;
+                                                    }>;
+                                                    after: VariantType<{
+                                                        readonly person: StringType;
+                                                        readonly request: StringType;
+                                                    }>;
+                                                }>;
+                                                patch: VariantType<{
+                                                    readonly person: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                    readonly request: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                            readonly position: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: StringType;
+                                                    after: StringType;
+                                                }>;
+                                            }>;
+                                            readonly activity: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: OptionType<StringType>;
+                                                    after: OptionType<StringType>;
+                                                }>;
+                                                patch: VariantType<{
+                                                    none: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    some: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: StringType;
+                                                            after: StringType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                            readonly offset: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: FloatType;
+                                                    after: FloatType;
+                                                }>;
+                                            }>;
+                                            readonly overtime: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: FloatType;
+                                                    after: FloatType;
+                                                }>;
+                                            }>;
+                                            readonly agreed: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: OptionType<BooleanType>;
+                                                    after: OptionType<BooleanType>;
+                                                }>;
+                                                patch: VariantType<{
+                                                    none: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: NullType;
+                                                            after: NullType;
+                                                        }>;
+                                                    }>;
+                                                    some: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: BooleanType;
+                                                            after: BooleanType;
+                                                        }>;
+                                                    }>;
+                                                }>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>;
+                            readonly requirements: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: DictType<StructType<{
+                                        readonly day: import("@elaraai/east").IntegerType;
+                                        readonly group: StringType;
+                                        readonly shift: StringType;
+                                    }>, StructType<{
+                                        readonly positions: import("@elaraai/east").IntegerType;
+                                        readonly hours: DictType<StringType, FloatType>;
+                                    }>>;
+                                    after: DictType<StructType<{
+                                        readonly day: import("@elaraai/east").IntegerType;
+                                        readonly group: StringType;
+                                        readonly shift: StringType;
+                                    }>, StructType<{
+                                        readonly positions: import("@elaraai/east").IntegerType;
+                                        readonly hours: DictType<StringType, FloatType>;
+                                    }>>;
+                                }>;
+                                patch: DictType<StructType<{
+                                    readonly day: import("@elaraai/east").IntegerType;
+                                    readonly group: StringType;
+                                    readonly shift: StringType;
+                                }>, VariantType<{
+                                    delete: StructType<{
+                                        readonly positions: import("@elaraai/east").IntegerType;
+                                        readonly hours: DictType<StringType, FloatType>;
+                                    }>;
+                                    insert: StructType<{
+                                        readonly positions: import("@elaraai/east").IntegerType;
+                                        readonly hours: DictType<StringType, FloatType>;
+                                    }>;
+                                    update: VariantType<{
+                                        unchanged: NullType;
+                                        replace: StructType<{
+                                            before: StructType<{
+                                                readonly positions: import("@elaraai/east").IntegerType;
+                                                readonly hours: DictType<StringType, FloatType>;
+                                            }>;
+                                            after: StructType<{
+                                                readonly positions: import("@elaraai/east").IntegerType;
+                                                readonly hours: DictType<StringType, FloatType>;
+                                            }>;
+                                        }>;
+                                        patch: StructType<{
+                                            readonly positions: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: import("@elaraai/east").IntegerType;
+                                                    after: import("@elaraai/east").IntegerType;
+                                                }>;
+                                            }>;
+                                            readonly hours: VariantType<{
+                                                unchanged: NullType;
+                                                replace: StructType<{
+                                                    before: DictType<StringType, FloatType>;
+                                                    after: DictType<StringType, FloatType>;
+                                                }>;
+                                                patch: DictType<StringType, VariantType<{
+                                                    delete: FloatType;
+                                                    insert: FloatType;
+                                                    update: VariantType<{
+                                                        unchanged: NullType;
+                                                        replace: StructType<{
+                                                            before: FloatType;
+                                                            after: FloatType;
+                                                        }>;
+                                                    }>;
+                                                }>>;
+                                            }>;
+                                        }>;
+                                    }>;
+                                }>>;
+                            }>;
+                            readonly dismissed: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: SetType<StringType>;
+                                    after: SetType<StringType>;
+                                }>;
+                                patch: DictType<StringType, VariantType<{
+                                    delete: NullType;
+                                    insert: NullType;
+                                }>>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+            readonly place: OptionType<VariantType<{
+                readonly ordered: VariantType<{
+                    readonly start: NullType;
+                    readonly end: NullType;
+                    readonly before: StringType;
+                    readonly after: StringType;
+                }>;
+                readonly keyOrder: NullType;
+            }>>;
+        }>>;
+    }>], VariantType<{
+        readonly applied: StructType<{
+            readonly revision: OptionType<StringType>;
+        }>;
+        readonly rejected: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<import("@elaraai/east").IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+        readonly conflict: ArrayType<StructType<{
+            readonly entry: StringType;
+            readonly row: OptionType<import("@elaraai/east").IntegerType>;
+            readonly field: OptionType<StringType>;
+            readonly message: StringType;
+        }>>;
+    }>>;
+    readonly window: OptionType<StructType<{
+        readonly id: StringType;
+        readonly page: FunctionType<[import("@elaraai/east").IntegerType, import("@elaraai/east").IntegerType], OptionType<DictType<DateTimeType, StructType<{
+            readonly status: VariantType<{
+                readonly draft: NullType;
+                readonly published: StructType<{
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+            readonly assignments: DictType<StringType, StructType<{
+                readonly slot: StructType<{
+                    readonly day: import("@elaraai/east").IntegerType;
+                    readonly group: StringType;
+                    readonly shift: StringType;
+                }>;
+                readonly who: VariantType<{
+                    readonly person: StringType;
+                    readonly request: StringType;
+                }>;
+                readonly position: StringType;
+                readonly activity: OptionType<StringType>;
+                readonly offset: FloatType;
+                readonly overtime: FloatType;
+                readonly agreed: OptionType<BooleanType>;
+            }>>;
+            readonly requirements: DictType<StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>, StructType<{
+                readonly positions: import("@elaraai/east").IntegerType;
+                readonly hours: DictType<StringType, FloatType>;
+            }>>;
+            readonly dismissed: SetType<StringType>;
+        }>>>>;
+        readonly total: FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+        readonly seek: OptionType<FunctionType<[VariantType<{
+            readonly key: StringType;
+            readonly prefix: StringType;
+            readonly fields: StructType<{
+                readonly values: ArrayType<StringType>;
+                readonly prefix: OptionType<StringType>;
+            }>;
+            readonly range: StructType<{
+                readonly from: ArrayType<StringType>;
+                readonly to: ArrayType<StringType>;
+            }>;
+        }>], OptionType<StructType<{
+            readonly found: BooleanType;
+            readonly row: import("@elaraai/east").IntegerType;
+            readonly count: import("@elaraai/east").IntegerType;
+        }>>>>;
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+    }>>;
+    readonly people: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly group: StringType;
+        readonly position: StringType;
+        readonly skills: SetType<StringType>;
+        readonly contract: FloatType;
+        readonly agency: BooleanType;
+        readonly trainer: BooleanType;
+        readonly trainee: BooleanType;
+        readonly usual: OptionType<StringType>;
+    }>>;
+    readonly visiblePeople: OptionType<SetType<StringType>>;
+    readonly groups: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly skills: ArrayType<StructType<{
+            readonly key: StringType;
+            readonly label: StringType;
+            readonly code: StringType;
+        }>>;
+    }>>;
+    readonly duties: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly code: StringType;
+    }>>;
+    readonly shifts: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly code: StringType;
+        readonly start: StructType<{
+            readonly hour: import("@elaraai/east").IntegerType;
+            readonly minute: import("@elaraai/east").IntegerType;
+        }>;
+        readonly hours: FloatType;
+    }>>;
+    readonly positions: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly code: StringType;
+        readonly lead: BooleanType;
+    }>>;
+    readonly agencies: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+    }>>;
+    readonly rules: StructType<{
+        readonly rest: FloatType;
+        readonly lead: BooleanType;
+        readonly trainer: BooleanType;
+        readonly skill: BooleanType;
+        readonly agree: BooleanType;
+    }>;
+    readonly costs: OptionType<StructType<{
+        readonly currency: StringType;
+        readonly rates: StructType<{
+            readonly permanent: FloatType;
+            readonly overtime: FloatType;
+            readonly agency: FloatType;
+        }>;
+        readonly budget: OptionType<FloatType>;
+    }>>;
+    readonly forecast: DictType<DateTimeType, DictType<StructType<{
+        readonly day: import("@elaraai/east").IntegerType;
+        readonly group: StringType;
+        readonly shift: StringType;
+    }>, StructType<{
+        readonly positions: import("@elaraai/east").IntegerType;
+        readonly hours: DictType<StringType, FloatType>;
+    }>>>;
+    readonly proposals: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly week: DateTimeType;
+        readonly slot: StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>;
+        readonly person: StringType;
+        readonly reason: StringType;
+    }>>;
+    readonly check: OptionType<FunctionType<[StructType<{
+        readonly start: DateTimeType;
+        readonly week: StructType<{
+            readonly status: VariantType<{
+                readonly draft: NullType;
+                readonly published: StructType<{
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+            readonly assignments: DictType<StringType, StructType<{
+                readonly slot: StructType<{
+                    readonly day: import("@elaraai/east").IntegerType;
+                    readonly group: StringType;
+                    readonly shift: StringType;
+                }>;
+                readonly who: VariantType<{
+                    readonly person: StringType;
+                    readonly request: StringType;
+                }>;
+                readonly position: StringType;
+                readonly activity: OptionType<StringType>;
+                readonly offset: FloatType;
+                readonly overtime: FloatType;
+                readonly agreed: OptionType<BooleanType>;
+            }>>;
+            readonly requirements: DictType<StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>, StructType<{
+                readonly positions: import("@elaraai/east").IntegerType;
+                readonly hours: DictType<StringType, FloatType>;
+            }>>;
+            readonly dismissed: SetType<StringType>;
+        }>;
+        readonly context: StructType<{
+            readonly people: DictType<StringType, StructType<{
+                readonly key: StringType;
+                readonly name: StringType;
+                readonly group: StringType;
+                readonly position: StringType;
+                readonly skills: SetType<StringType>;
+                readonly contract: FloatType;
+                readonly agency: BooleanType;
+                readonly trainer: BooleanType;
+                readonly trainee: BooleanType;
+                readonly usual: OptionType<StringType>;
+            }>>;
+            readonly groups: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly skills: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly label: StringType;
+                    readonly code: StringType;
+                }>>;
+            }>>;
+            readonly duties: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly code: StringType;
+            }>>;
+            readonly shifts: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly code: StringType;
+                readonly start: StructType<{
+                    readonly hour: import("@elaraai/east").IntegerType;
+                    readonly minute: import("@elaraai/east").IntegerType;
+                }>;
+                readonly hours: FloatType;
+            }>>;
+            readonly positions: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly code: StringType;
+                readonly lead: BooleanType;
+            }>>;
+            readonly agencies: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly name: StringType;
+            }>>;
+            readonly rules: StructType<{
+                readonly rest: FloatType;
+                readonly lead: BooleanType;
+                readonly trainer: BooleanType;
+                readonly skill: BooleanType;
+                readonly agree: BooleanType;
+            }>;
+            readonly costs: OptionType<StructType<{
+                readonly currency: StringType;
+                readonly rates: StructType<{
+                    readonly permanent: FloatType;
+                    readonly overtime: FloatType;
+                    readonly agency: FloatType;
+                }>;
+                readonly budget: OptionType<FloatType>;
+            }>>;
+        }>;
+        readonly coverage: DictType<StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>, StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly filled: import("@elaraai/east").IntegerType;
+            readonly open: import("@elaraai/east").IntegerType;
+            readonly people: import("@elaraai/east").IntegerType;
+            readonly hours: StructType<{
+                readonly permanent: FloatType;
+                readonly agency: FloatType;
+                readonly overtime: FloatType;
+                readonly requested: FloatType;
+                readonly needed: FloatType;
+                readonly rostered: FloatType;
+            }>;
+            readonly lines: ArrayType<StructType<{
+                readonly skill: StringType;
+                readonly needed: FloatType;
+                readonly holders: OptionType<import("@elaraai/east").IntegerType>;
+                readonly capacity: OptionType<FloatType>;
+                readonly gap: FloatType;
+                readonly assigned: FloatType;
+            }>>;
+            readonly cost: FloatType;
+            readonly lead: BooleanType;
+            readonly trainer: BooleanType;
+        }>>;
+    }>], ArrayType<StructType<{
+        readonly kind: VariantType<{
+            readonly breach: NullType;
+            readonly gap: NullType;
+            readonly agree: NullType;
+            readonly proposal: NullType;
+        }>;
+        readonly tone: VariantType<{
+            readonly success: NullType;
+            readonly warning: NullType;
+            readonly danger: NullType;
+            readonly info: NullType;
+            readonly neutral: NullType;
+        }>;
+        readonly title: StringType;
+        readonly detail: StringType;
+        readonly slot: OptionType<StructType<{
+            readonly day: import("@elaraai/east").IntegerType;
+            readonly group: StringType;
+            readonly shift: StringType;
+        }>>;
+        readonly assignment: OptionType<StringType>;
+        readonly flag: OptionType<StringType>;
+        readonly fix: OptionType<VariantType<{
+            readonly request: StringType;
+            readonly agree: NullType;
+            readonly accept: StringType;
+            readonly move: StringType;
+            readonly start: FloatType;
+            readonly find: VariantType<{
+                readonly leads: NullType;
+                readonly trainers: NullType;
+                readonly skill: StringType;
+            }>;
+        }>>;
+    }>>>>;
+    readonly library: ArrayType<VariantType<{
+        readonly people: NullType;
+        readonly activities: NullType;
+        readonly tab: StructType<{
+            readonly name: StringType;
+            readonly icon: OptionType<StringType>;
+            readonly cards: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly label: StringType;
+                readonly meta: OptionType<StringType>;
+                readonly group: OptionType<StringType>;
+                readonly patch: OptionType<StructType<{
+                    readonly position: OptionType<StringType>;
+                    readonly activity: OptionType<OptionType<StringType>>;
+                    readonly offset: OptionType<FloatType>;
+                    readonly overtime: OptionType<FloatType>;
+                    readonly agreed: OptionType<OptionType<BooleanType>>;
+                }>>;
+            }>>;
+        }>;
+    }>>;
+    readonly inspector: OptionType<StructType<{
+        readonly assignment: OptionType<FunctionType<[StructType<{
+            readonly slot: StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly offset: FloatType;
+            readonly overtime: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+        }>, FunctionType<[StructType<{
+            readonly slot: StructType<{
+                readonly day: import("@elaraai/east").IntegerType;
+                readonly group: StringType;
+                readonly shift: StringType;
+            }>;
+            readonly who: VariantType<{
+                readonly person: StringType;
+                readonly request: StringType;
+            }>;
+            readonly position: StringType;
+            readonly activity: OptionType<StringType>;
+            readonly offset: FloatType;
+            readonly overtime: FloatType;
+            readonly agreed: OptionType<BooleanType>;
+        }>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+        readonly requirement: OptionType<FunctionType<[StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>, FunctionType<[StructType<{
+            readonly positions: import("@elaraai/east").IntegerType;
+            readonly hours: DictType<StringType, FloatType>;
+        }>], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    }>>;
+    readonly slice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: StringType;
+            readonly read: FunctionType<[], StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: import("@elaraai/east").IntegerType;
+                        readonly to: import("@elaraai/east").IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: 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: SetType<StringType>;
+                            readonly notIn: 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: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: 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: SetType<StringType>;
+                                readonly notIn: 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: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<SetType<StringType>>;
+                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly resolution: OptionType<VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>>;
+            readonly write: FunctionType<[StructType<{
+                readonly range: OptionType<VariantType<{
+                    readonly datetime: StructType<{
+                        readonly from: DateTimeType;
+                        readonly to: DateTimeType;
+                    }>;
+                    readonly datetimePreset: VariantType<{
+                        readonly today: NullType;
+                        readonly last7d: NullType;
+                        readonly last30d: NullType;
+                        readonly last90d: NullType;
+                        readonly ytd: NullType;
+                    }>;
+                    readonly integer: StructType<{
+                        readonly from: import("@elaraai/east").IntegerType;
+                        readonly to: import("@elaraai/east").IntegerType;
+                    }>;
+                    readonly float: StructType<{
+                        readonly from: FloatType;
+                        readonly to: 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: SetType<StringType>;
+                            readonly notIn: 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: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: 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: SetType<StringType>;
+                                readonly notIn: 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: import("@elaraai/east").IntegerType;
+                                readonly neq: import("@elaraai/east").IntegerType;
+                                readonly lt: import("@elaraai/east").IntegerType;
+                                readonly lte: import("@elaraai/east").IntegerType;
+                                readonly gt: import("@elaraai/east").IntegerType;
+                                readonly gte: import("@elaraai/east").IntegerType;
+                                readonly in: SetType<import("@elaraai/east").IntegerType>;
+                            }>;
+                        }>;
+                        readonly float: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly lt: FloatType;
+                                readonly lte: FloatType;
+                                readonly gt: FloatType;
+                                readonly gte: FloatType;
+                            }>;
+                        }>;
+                        readonly datetime: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly before: DateTimeType;
+                                readonly after: DateTimeType;
+                                readonly between: StructType<{
+                                    readonly from: DateTimeType;
+                                    readonly to: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                        readonly boolean: StructType<{
+                            readonly fieldId: StringType;
+                            readonly op: VariantType<{
+                                readonly is: BooleanType;
+                            }>;
+                        }>;
+                    }>>;
+                    readonly group: OptionType<StringType>;
+                }>>;
+                readonly activeCohorts: SetType<StringType>;
+                readonly breakdown: OptionType<StructType<{
+                    readonly fieldId: StringType;
+                    readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+                }>>;
+                readonly search: OptionType<StringType>;
+                readonly visible: OptionType<SetType<StringType>>;
+                readonly selectedIndex: OptionType<import("@elaraai/east").IntegerType>;
+                readonly resolution: OptionType<VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>], NullType>;
+            readonly setRange: FunctionType<[OptionType<VariantType<{
+                readonly datetime: StructType<{
+                    readonly from: DateTimeType;
+                    readonly to: DateTimeType;
+                }>;
+                readonly datetimePreset: VariantType<{
+                    readonly today: NullType;
+                    readonly last7d: NullType;
+                    readonly last30d: NullType;
+                    readonly last90d: NullType;
+                    readonly ytd: NullType;
+                }>;
+                readonly integer: StructType<{
+                    readonly from: import("@elaraai/east").IntegerType;
+                    readonly to: import("@elaraai/east").IntegerType;
+                }>;
+                readonly float: StructType<{
+                    readonly from: FloatType;
+                    readonly to: 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: SetType<StringType>;
+                        readonly notIn: 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: import("@elaraai/east").IntegerType;
+                        readonly neq: import("@elaraai/east").IntegerType;
+                        readonly lt: import("@elaraai/east").IntegerType;
+                        readonly lte: import("@elaraai/east").IntegerType;
+                        readonly gt: import("@elaraai/east").IntegerType;
+                        readonly gte: import("@elaraai/east").IntegerType;
+                        readonly in: SetType<import("@elaraai/east").IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly removeFilter: FunctionType<[import("@elaraai/east").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: SetType<StringType>;
+                            readonly notIn: 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: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], 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: SetType<StringType>;
+                            readonly notIn: 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: import("@elaraai/east").IntegerType;
+                            readonly neq: import("@elaraai/east").IntegerType;
+                            readonly lt: import("@elaraai/east").IntegerType;
+                            readonly lte: import("@elaraai/east").IntegerType;
+                            readonly gt: import("@elaraai/east").IntegerType;
+                            readonly gte: import("@elaraai/east").IntegerType;
+                            readonly in: SetType<import("@elaraai/east").IntegerType>;
+                        }>;
+                    }>;
+                    readonly float: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly lt: FloatType;
+                            readonly lte: FloatType;
+                            readonly gt: FloatType;
+                            readonly gte: FloatType;
+                        }>;
+                    }>;
+                    readonly datetime: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly before: DateTimeType;
+                            readonly after: DateTimeType;
+                            readonly between: StructType<{
+                                readonly from: DateTimeType;
+                                readonly to: DateTimeType;
+                            }>;
+                        }>;
+                    }>;
+                    readonly boolean: StructType<{
+                        readonly fieldId: StringType;
+                        readonly op: VariantType<{
+                            readonly is: BooleanType;
+                        }>;
+                    }>;
+                }>>;
+                readonly group: OptionType<StringType>;
+            }>], NullType>;
+            readonly removeCohort: FunctionType<[StringType], NullType>;
+            readonly toggleCohort: FunctionType<[StringType], NullType>;
+            readonly setBreakdown: FunctionType<[OptionType<StructType<{
+                readonly fieldId: StringType;
+                readonly limit: OptionType<import("@elaraai/east").IntegerType>;
+            }>>], NullType>;
+            readonly setSearch: FunctionType<[OptionType<StringType>], NullType>;
+            readonly setVisible: FunctionType<[OptionType<SetType<StringType>>], NullType>;
+            readonly select: FunctionType<[OptionType<import("@elaraai/east").IntegerType>], NullType>;
+            readonly isActive: FunctionType<[], BooleanType>;
+            readonly activeCount: FunctionType<[], import("@elaraai/east").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: 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<[], import("@elaraai/east").IntegerType>;
+            readonly resultCount: FunctionType<[], import("@elaraai/east").IntegerType>;
+            readonly groups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: import("@elaraai/east").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: FloatType;
+                        readonly time: DateTimeType;
+                    }>;
+                    readonly value: FloatType;
+                    readonly size: OptionType<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, import("@elaraai/east").IntegerType>>;
+            readonly toggleFilter: FunctionType<[VariantType<{
+                readonly string: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly eq: StringType;
+                        readonly neq: StringType;
+                        readonly in: SetType<StringType>;
+                        readonly notIn: 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: import("@elaraai/east").IntegerType;
+                        readonly neq: import("@elaraai/east").IntegerType;
+                        readonly lt: import("@elaraai/east").IntegerType;
+                        readonly lte: import("@elaraai/east").IntegerType;
+                        readonly gt: import("@elaraai/east").IntegerType;
+                        readonly gte: import("@elaraai/east").IntegerType;
+                        readonly in: SetType<import("@elaraai/east").IntegerType>;
+                    }>;
+                }>;
+                readonly float: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly lt: FloatType;
+                        readonly lte: FloatType;
+                        readonly gt: FloatType;
+                        readonly gte: FloatType;
+                    }>;
+                }>;
+                readonly datetime: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly before: DateTimeType;
+                        readonly after: DateTimeType;
+                        readonly between: StructType<{
+                            readonly from: DateTimeType;
+                            readonly to: DateTimeType;
+                        }>;
+                    }>;
+                }>;
+                readonly boolean: StructType<{
+                    readonly fieldId: StringType;
+                    readonly op: VariantType<{
+                        readonly is: BooleanType;
+                    }>;
+                }>;
+            }>], NullType>;
+            readonly facetGroups: FunctionType<[], ArrayType<StructType<{
+                readonly key: StringType;
+                readonly count: import("@elaraai/east").IntegerType;
+                readonly color: StringType;
+            }>>>;
+            readonly setResolution: FunctionType<[OptionType<VariantType<{
+                readonly auto: NullType;
+                readonly hour: NullType;
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
+            }>>], NullType>;
+        }>;
+        readonly affordances: ArrayType<VariantType<{
+            readonly filter: NullType;
+            readonly search: NullType;
+            readonly breakdown: NullType;
+            readonly range: NullType;
+            readonly cohort: NullType;
+            readonly brush: NullType;
+            readonly presets: NullType;
+            readonly legend: NullType;
+            readonly resolution: NullType;
+            readonly summary: NullType;
+        }>>;
+    }>>;
+    readonly settings: StructType<{
+        readonly layout: VariantType<{
+            readonly shifts: NullType;
+            readonly people: NullType;
+        }>;
+        readonly period: VariantType<{
+            readonly day: NullType;
+            readonly week: NullType;
+        }>;
+        readonly date: OptionType<DateTimeType>;
+        readonly weekStart: VariantType<{
+            readonly monday: NullType;
+            readonly sunday: NullType;
+        }>;
+        readonly density: VariantType<{
+            readonly compact: NullType;
+            readonly comfortable: NullType;
+        }>;
+        readonly chipSkills: BooleanType;
+        readonly requirements: BooleanType;
+        readonly readOnly: BooleanType;
+    }>;
+    readonly id: OptionType<StringType>;
+    readonly recordSlice: OptionType<StructType<{
+        readonly slice: StructType<{
+            readonly key: import("@elaraai/east").StringType;
+            readonly config: StructType<{
+                readonly fields: ArrayType<StructType<{
+                    readonly fieldId: import("@elaraai/east").StringType;
+                    readonly label: import("@elaraai/east").StringType;
+                    readonly kind: import("@elaraai/east").StringType;
+                    readonly optional: import("@elaraai/east").BooleanType;
+                    readonly multiple: import("@elaraai/east").BooleanType;
+                    readonly set: import("@elaraai/east").BooleanType;
+                    readonly values: ArrayType<StructType<{
+                        readonly value: import("@elaraai/east").StringType;
+                        readonly label: import("@elaraai/east").StringType;
+                    }>>;
+                    readonly format: OptionType<VariantType<{
+                        readonly number: NullType;
+                        readonly currency: StructType<{
+                            readonly code: import("@elaraai/east").StringType;
+                            readonly compact: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly percent: NullType;
+                        readonly compact: NullType;
+                        readonly date: import("@elaraai/east").StringType;
+                        readonly time: import("@elaraai/east").StringType;
+                        readonly datetime: import("@elaraai/east").StringType;
+                    }>>;
+                }>>;
+                readonly indexes: ArrayType<StructType<{
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly fields: ArrayType<import("@elaraai/east").StringType>;
+                    readonly sets: import("@elaraai/east").SetType<import("@elaraai/east").StringType>;
+                    readonly structured: import("@elaraai/east").BooleanType;
+                    readonly interval: OptionType<StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                        readonly optional: import("@elaraai/east").BooleanType;
+                    }>>;
+                }>>;
+                readonly range: OptionType<import("@elaraai/east").StringType>;
+                readonly search: ArrayType<import("@elaraai/east").StringType>;
+                readonly presets: ArrayType<StructType<{
+                    readonly id: import("@elaraai/east").StringType;
+                    readonly name: import("@elaraai/east").StringType;
+                    readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                        readonly values: ArrayType<import("@elaraai/east").StringType>;
+                        readonly range: StructType<{
+                            readonly from: import("@elaraai/east").StringType;
+                            readonly to: import("@elaraai/east").StringType;
+                        }>;
+                        readonly prefix: import("@elaraai/east").StringType;
+                    }>>;
+                }>>;
+            }>;
+            readonly read: import("@elaraai/east").FunctionType<[], StructType<{
+                readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                    readonly values: ArrayType<import("@elaraai/east").StringType>;
+                    readonly range: StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                    }>;
+                    readonly prefix: import("@elaraai/east").StringType;
+                }>>;
+                readonly preset: OptionType<import("@elaraai/east").StringType>;
+                readonly resolution: OptionType<VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>>;
+            readonly write: import("@elaraai/east").FunctionType<[StructType<{
+                readonly where: import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                    readonly values: ArrayType<import("@elaraai/east").StringType>;
+                    readonly range: StructType<{
+                        readonly from: import("@elaraai/east").StringType;
+                        readonly to: import("@elaraai/east").StringType;
+                    }>;
+                    readonly prefix: import("@elaraai/east").StringType;
+                }>>;
+                readonly preset: OptionType<import("@elaraai/east").StringType>;
+                readonly resolution: OptionType<VariantType<{
+                    readonly auto: NullType;
+                    readonly hour: NullType;
+                    readonly day: NullType;
+                    readonly week: NullType;
+                    readonly month: NullType;
+                    readonly quarter: NullType;
+                    readonly year: NullType;
+                }>>;
+            }>], NullType>;
+            readonly choose: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, ArrayType<import("@elaraai/east").StringType>], NullType>;
+            readonly range: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+            readonly prefix: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], NullType>;
+            readonly clear: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+            readonly clearAll: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly count: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly countWhere: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                readonly range: StructType<{
+                    readonly from: import("@elaraai/east").StringType;
+                    readonly to: import("@elaraai/east").StringType;
+                }>;
+                readonly prefix: import("@elaraai/east").StringType;
+            }>>], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly total: import("@elaraai/east").FunctionType<[], OptionType<import("@elaraai/east").IntegerType>>;
+            readonly domain: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<StructType<{
+                readonly from: import("@elaraai/east").StringType;
+                readonly to: import("@elaraai/east").StringType;
+            }>>>;
+            readonly values: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<StructType<{
+                readonly value: import("@elaraai/east").StringType;
+                readonly label: import("@elaraai/east").StringType;
+                readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                readonly selected: import("@elaraai/east").BooleanType;
+                readonly error: OptionType<import("@elaraai/east").StringType>;
+            }>>>;
+            readonly suggest: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], OptionType<ArrayType<StructType<{
+                readonly value: import("@elaraai/east").StringType;
+                readonly label: import("@elaraai/east").StringType;
+                readonly count: OptionType<import("@elaraai/east").IntegerType>;
+                readonly selected: import("@elaraai/east").BooleanType;
+                readonly error: OptionType<import("@elaraai/east").StringType>;
+            }>>>>;
+            readonly replaces: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], ArrayType<import("@elaraai/east").StringType>>;
+            readonly togglePreset: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], NullType>;
+            readonly setResolution: import("@elaraai/east").FunctionType<[OptionType<VariantType<{
+                readonly auto: NullType;
+                readonly hour: NullType;
+                readonly day: NullType;
+                readonly week: NullType;
+                readonly month: NullType;
+                readonly quarter: NullType;
+                readonly year: NullType;
+            }>>], NullType>;
+            readonly retry: import("@elaraai/east").FunctionType<[], NullType>;
+            readonly sourceId: import("@elaraai/east").StringType;
+            readonly readEntry: import("@elaraai/east").FunctionType<[import("@elaraai/east").StringType], OptionType<OptionType<import("@elaraai/east").BlobType>>>;
+            readonly contains: import("@elaraai/east").FunctionType<[import("@elaraai/east").DictType<import("@elaraai/east").StringType, VariantType<{
+                readonly values: ArrayType<import("@elaraai/east").StringType>;
+                readonly range: StructType<{
+                    readonly from: import("@elaraai/east").StringType;
+                    readonly to: import("@elaraai/east").StringType;
+                }>;
+                readonly prefix: import("@elaraai/east").StringType;
+            }>>, import("@elaraai/east").StringType], OptionType<import("@elaraai/east").BooleanType>>;
+        }>;
+        readonly affordances: ArrayType<VariantType<{
+            readonly fields: NullType;
+            readonly search: NullType;
+            readonly range: NullType;
+            readonly presets: NullType;
+            readonly resolution: NullType;
+            readonly brush: NullType;
+            readonly summary: NullType;
+        }>>;
+        readonly persist: OptionType<VariantType<{
+            readonly local: NullType;
+            readonly session: NullType;
+            readonly url: NullType;
+        }>>;
+    }>>;
+    readonly visibleSource: OptionType<RowSourceType<ArrayType<StringType>>>;
+}>>;
+/** Author-facing Roster props; data can come from reactive records. */
+export interface RosterProps {
+    /** Weeks record bound with its patch mutation. */
+    weeks: RosterWeeksHandle;
+    /** Paged access to the same record; avoids reading history whole. */
+    window?: SubtypeExprOrValue<typeof RosterWindowType>;
+    /** Complete resolved staff, commonly Roster.people(bound.read(), accessors). */
+    people: SubtypeExprOrValue<ArrayType<T.RosterPersonType>>;
+    /** Original staff keys, or Slice.rows(recordSlice); coverage still uses complete staff. */
+    visiblePeople?: RowSourceInput<SetType<StringType>>;
+    /** Nonempty groups in display order, including their skills. */
+    groups: SubtypeExprOrValue<ArrayType<T.RosterGroupType>>;
+    /** Nonempty recurring shifts. */
+    shifts: SubtypeExprOrValue<ArrayType<T.RosterShiftType>>;
+    /** Duties available to every group. */
+    duties?: SubtypeExprOrValue<ArrayType<T.RosterSkillType>>;
+    /** Positions; defaults to Associate. */
+    positions?: SubtypeExprOrValue<ArrayType<T.RosterPositionType>>;
+    /** Agencies from which staffing can be requested. */
+    agencies?: SubtypeExprOrValue<ArrayType<T.RosterAgencyType>>;
+    /** Built-in warnings; defaults to ten hours' rest and all checks enabled. */
+    rules?: ExprType<T.RosterRulesType> | {
+        rest?: SubtypeExprOrValue<FloatType>;
+        lead?: SubtypeExprOrValue<BooleanType>;
+        trainer?: SubtypeExprOrValue<BooleanType>;
+        skill?: SubtypeExprOrValue<BooleanType>;
+        agree?: SubtypeExprOrValue<BooleanType>;
+    };
+    /** Cost rates and optional daily budget. */
+    costs?: SubtypeExprOrValue<T.RosterCostsType>;
+    /** Targets used only when a week has not yet been created. */
+    forecast?: SubtypeExprOrValue<DictType<DateTimeType, T.RosterRequirementsType>>;
+    /** Suggested placements from application data. */
+    proposals?: SubtypeExprOrValue<ArrayType<T.RosterProposalType>>;
+    /** Additional warnings over the complete draft; exceptions are reported without hiding built-in checks. */
+    check?: SubtypeExprOrValue<FunctionType<[T.RosterCheckContextType], ArrayType<T.RosterIssueType>>>;
+    /** Tabs to show; omitted, no library pane. */
+    library?: readonly RosterLibraryTab[];
+    /** Inspector with shared forms, or author-provided typed forms. */
+    inspector?: boolean | {
+        /** Typed assignment editor. */
+        assignment?: SubtypeExprOrValue<typeof RosterAssignmentFormType>;
+        /** Typed target editor. */
+        requirement?: SubtypeExprOrValue<typeof RosterRequirementFormType>;
+    };
+    /** Shared Slice toolbar. A record Slice narrows visible staff; a local date Slice can select the week. */
+    slice?: {
+        slice: SubtypeExprOrValue<SliceBindType>;
+        affordances?: SliceAffordanceLiteral[];
+    } | RecordSliceChromeOptions;
+    /** Initial view, persisted under id. */
+    view?: {
+        layout?: "shifts" | "people";
+        period?: "day" | "week";
+        date?: SubtypeExprOrValue<DateTimeType>;
+    };
+    /** Week boundary; Monday by default. */
+    week?: {
+        start?: "monday" | "sunday";
+    };
+    /** Assignment spacing; comfortable by default. */
+    density?: "compact" | "comfortable";
+    /** Shows held skill codes on assignment chips. */
+    chipSkills?: SubtypeExprOrValue<BooleanType>;
+    /** Shows requirement rows in the shift grid. */
+    requirements?: SubtypeExprOrValue<BooleanType>;
+    /** Disables edits; published weeks are always read-only. */
+    readOnly?: SubtypeExprOrValue<BooleanType>;
+    /** Stable viewer identity when multiple Rosters share a surface. */
+    id?: string;
+}
+/** Assembles a payload; domain and interaction programs live outside the tag. @internal */
+export declare function createRosterPayload(props: RosterProps): ExprType<typeof RosterPayloadType>;
+/** The tag, domain functions and authoring helpers. */
+export interface RosterNamespace {
+    /** Renders a roster bound to one weeks record. */
+    (props: RosterProps): UIElement;
+    /** Adapts complete staff from keyed data. */
+    people: typeof rosterPeople;
+    /** Computes coverage without a browser. */
+    coverage: typeof rosterCoverage;
+    /** Computes built-in warnings without a browser. */
+    check: typeof rosterCheck;
+    /** Computes each person's total hours. */
+    weekHours: typeof rosterWeekHours;
+    /** Computes rest before and after an assignment. */
+    rest: typeof rosterRest;
+    /** Describes a restricted library-card patch. */
+    patch: typeof rosterPatch;
+    /** Declares optional shared-library tabs. */
+    library: {
+        people: typeof rosterPeopleTab;
+        activities: typeof rosterActivitiesTab;
+        tab: typeof rosterLibraryTab;
+    };
+    /** Roster's public domain types. */
+    Types: {
+        Clock: typeof ScheduleClockType;
+        Slot: T.RosterSlotType;
+        Who: T.RosterWhoType;
+        Assignment: T.RosterAssignmentType;
+        Requirement: T.RosterRequirementType;
+        Requirements: T.RosterRequirementsType;
+        Status: T.RosterStatusType;
+        Week: T.RosterWeekType;
+        Weeks: T.RosterWeeksType;
+        Skill: T.RosterSkillType;
+        Group: T.RosterGroupType;
+        Shift: T.RosterShiftType;
+        Position: T.RosterPositionType;
+        Agency: T.RosterAgencyType;
+        Person: T.RosterPersonType;
+        Rules: T.RosterRulesType;
+        Costs: T.RosterCostsType;
+        Context: T.RosterContextType;
+        CoverageLine: T.RosterCoverageLineType;
+        Coverage: T.RosterCoverageType;
+        Proposal: T.RosterProposalType;
+        Fix: T.RosterFixType;
+        Issue: T.RosterIssueType;
+        CheckContext: T.RosterCheckContextType;
+        Patch: typeof RosterPatchType;
+        Layout: typeof RosterLayoutType;
+        Period: typeof RosterPeriodType;
+    };
+}
+/**
+ * Plans staffing with an internal shared BuilderFrame, Slice toolbar and editing session.
+ * @param props - Bound weeks, staff, shift configuration and optional library/inspector
+ * @returns The Roster extension
+ * @remarks One gesture is one undo step; Save and Publish each write one complete week. On narrow containers the same commands are explicit card actions.
+ */
+export declare const Roster: RosterNamespace;
+//# sourceMappingURL=index.d.ts.map