@reopt-ai/opt-ui 1.10.0 → 1.12.0

package/dist/{field-sidebar-DWfJAJlx.d.ts → field-sidebar-uXmoyvd7.d.cts}

@@ -1,5 +1,5 @@
 
-import { A as FormFieldDef, D as FaqItem, E as FailureItem, F as ProjectDef, G as ToolbarButtonDef, L as SelectOption, P as NavItemDef, R as StatCard, S as EnvGroupDef, a as FieldDataType, b as DeploymentStep, j as MenuDef, r as TruncationSide, u as BranchDef, x as DomainDef, y as CommandDef, z as TabDef } from "./text-truncate-BGr7bB_8.js";
+import { B as StatCard, C as DomainDef, I as NavItemDef, L as ProjectDef, M as FormFieldDef, N as MenuDef, O as FailureItem, S as DeploymentStep, V as TabDef, a as FieldDataType, f as BranchDef, k as FaqItem, q as ToolbarButtonDef, r as TruncationSide, w as EnvGroupDef, x as CommandDef, z as SelectOption } from "./text-truncate-CQyfUZvq.cjs";
 import * as React from "react";
 import { ReactNode, Ref } from "react";
 import { TimeGranularity, TimeRange, TimeRange as TimeRange$1, TimeSeriesAnnotation, TimeSeriesChartProps, TimeSeriesDef, TimeSeriesPoint } from "@reopt-ai/opt-charts";
@@ -288,7 +288,18 @@ interface DataTableProps<T> {
   data: T[];
   columns: ColumnDef<T>[];
   keyExtractor: (row: T) => string;
+  /**
+   * A heading above the table. Omitted by default — most tables sit under a
+   * page heading that already names them, and a second one in English was
+   * showing up on screens that had never asked for a title.
+   */
   title?: string;
+  /**
+   * The grid's accessible name, for a table that shows no heading. `title`
+   * wins when both are given, so a visible heading is never contradicted by a
+   * different spoken one.
+   */
+  ariaLabel?: string;
   onRowClick?: (row: T) => void;
   emptyMessage?: string;
   /** Highlight a single row by its key */
@@ -313,7 +324,7 @@ interface DataTableProps<T> {
   className?: string;
 }
 /** Renders the data table component. */
-declare function DataTable<T>({ data, columns, keyExtractor, title, onRowClick, emptyMessage, activeRowId, sortable, selectable, selectedKeys, onSelectionChange, expandable, renderExpanded, pageSize, stickyHeader, resizableColumns, onSort: onSortExternal, className }: DataTableProps<T>): import("react").JSX.Element;
+declare function DataTable<T>({ data, columns, keyExtractor, title, ariaLabel, onRowClick, emptyMessage, activeRowId, sortable, selectable, selectedKeys, onSelectionChange, expandable, renderExpanded, pageSize, stickyHeader, resizableColumns, onSort: onSortExternal, className }: DataTableProps<T>): import("react").JSX.Element;
 //#endregion
 //#region src/shells/notification-toast.d.ts
 /** Defines the toast action shape. */
@@ -491,6 +502,367 @@ declare namespace WorkflowCanvas {
   var displayName: string;
 }
 //#endregion
+//#region src/shells/event-timeline.d.ts
+/** Semantic colour of a timeline node. */
+type EventTimelineTone = "default" | "accent" | "success" | "warning" | "danger";
+/** One event on the timeline. */
+interface EventTimelineItem {
+  id: string;
+  /** Event name — the headline of the row. */
+  name: ReactNode;
+  /** ISO timestamp. Drives the shown time and the gap from the previous row. */
+  timestamp: string;
+  /** Secondary line locating the event: a path, a target, an object id. */
+  detail?: ReactNode;
+  icon?: ReactNode;
+  tone?: EventTimelineTone;
+  /**
+   * Payload revealed when the row is expanded. Rendering it inline rather
+   * than in a separate panel is what lets someone read a sequence and its
+   * evidence without losing their place in the sequence.
+   */
+  properties?: Record<string, unknown>;
+  /** Replaces the default property table when the payload needs shaping. */
+  content?: ReactNode;
+  href?: string;
+}
+/** A run of events that belong together — typically one session. */
+interface EventTimelineGroup {
+  id: string;
+  title: ReactNode;
+  /** Facts about the run: duration, event count, entry channel. */
+  meta?: ReactNode;
+  href?: string;
+  items: EventTimelineItem[];
+  /** Collapsed groups still show their header, so the shape stays readable. */
+  defaultOpen?: boolean;
+}
+/** Localized strings for the event timeline. */
+interface EventTimelineLabels {
+  emptyTitle?: string;
+  emptyDescription?: string;
+  expand?: string;
+  collapse?: string;
+  loadMore?: string;
+  /** Gap between two adjacent events, e.g. "+2 minutes". */
+  gap?: (duration: string) => string;
+  /** Announced for a gap the reader cannot see, e.g. across a collapsed group. */
+  properties?: string;
+  openGroup?: (title: string) => string;
+}
+/** Props for the event timeline component. */
+interface EventTimelineProps {
+  /** Flat list. Ignored when `groups` is given. */
+  items?: EventTimelineItem[];
+  /** Grouped list — the shape a user's history takes once it spans sessions. */
+  groups?: EventTimelineGroup[];
+  /**
+   * Show the elapsed time between adjacent events. This is the difference
+   * between a list of things that happened and a record of how someone moved:
+   * a four-minute pause before a checkout event is the finding.
+   */
+  showGaps?: boolean;
+  /** Reading direction of the supplied items. */
+  order?: "desc" | "asc";
+  /** Suppress gap labels below this many milliseconds. */
+  minGapMs?: number;
+  loading?: boolean;
+  hasMore?: boolean;
+  onLoadMore?: () => void;
+  onItemSelect?: (item: EventTimelineItem) => void;
+  locale?: string;
+  labels?: EventTimelineLabels;
+  className?: string;
+}
+/**
+ * EventTimeline — a sequence of events, read as a sequence.
+ *
+ * A table of events answers "what happened" and hides "how it went": the rows
+ * are evenly spaced no matter whether they were two seconds or two hours
+ * apart, and the payload that would explain a row lives in a column nobody
+ * widened. This renders the same data as an ordered rail, labels the elapsed
+ * time between adjacent events, and opens each payload in place. Grouping by
+ * session restores the boundary that makes a history legible.
+ *
+ * @example
+ * ```tsx
+ * <EventTimeline
+ *   groups={sessions.map((session) => ({
+ *     id: session.id,
+ *     title: session.entryPath,
+ *     meta: `${session.duration} · ${session.events} events`,
+ *     items: session.events,
+ *   }))}
+ *   showGaps
+ * />
+ * ```
+ */
+declare function EventTimeline({ items, groups, showGaps, order, minGapMs, loading, hasMore, onLoadMore, onItemSelect, locale, labels: customLabels, className }: EventTimelineProps): import("react").JSX.Element;
+declare namespace EventTimeline {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/score-breakdown.d.ts
+/** One contributing dimension of a composite score. */
+interface ScoreAxis {
+  id: string;
+  label: string;
+  /** Value on the same scale as the headline score. */
+  value: number;
+  /**
+   * What the axis measures. A composite score that cannot be taken apart is
+   * a number people learn to ignore; naming each axis is what makes a low
+   * one actionable.
+   */
+  hint?: string;
+  /** Share of the total this axis carries, 0–1. Rendered so the sum audits. */
+  weight?: number;
+}
+/** A named range of the score, used to colour and caption the headline. */
+interface ScoreBand {
+  /** Lowest value in the band, inclusive. */
+  min: number;
+  label: string;
+  tone?: "default" | "success" | "warning" | "error";
+}
+/** Localized strings for the score breakdown. */
+interface ScoreBreakdownLabels {
+  title?: string;
+  outOf?: (max: number) => string;
+  weight?: (percent: string) => string;
+  empty?: string;
+}
+/** Props for the score breakdown component. */
+interface ScoreBreakdownProps {
+  score: number;
+  max?: number;
+  axes: ScoreAxis[];
+  bands?: ScoreBand[];
+  /** Sentence under the headline explaining how the score is derived. */
+  formula?: ReactNode;
+  loading?: boolean;
+  labels?: ScoreBreakdownLabels;
+  className?: string;
+}
+/**
+ * ScoreBreakdown — a composite score you can argue with.
+ *
+ * Engagement, health and risk scores all collapse several signals into one
+ * number, and the number alone tells nobody what to do about it. Showing the
+ * axes and their weights beside the headline turns "43" into "recent, but
+ * shallow", which is a finding rather than a verdict.
+ */
+declare function ScoreBreakdown({ score, max, axes, bands, formula, loading, labels: customLabels, className }: ScoreBreakdownProps): import("react").JSX.Element;
+declare namespace ScoreBreakdown {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/flyout.d.ts
+/** Localized strings for the flyout. */
+interface FlyoutLabels {
+  close?: string;
+}
+/** Props for the flyout component. */
+interface FlyoutProps {
+  open: boolean;
+  onClose: () => void;
+  title?: ReactNode;
+  /** One line under the title — what this panel is showing. */
+  description?: ReactNode;
+  /**
+   * `overlay` floats the panel over the page. `inline` renders a plain
+   * `<aside>` and leaves placement to the parent's layout, which is how a
+   * list keeps both itself and the preview visible on a wide screen.
+   */
+  type?: "overlay" | "inline";
+  side?: "right" | "left";
+  size?: "sm" | "md" | "lg";
+  /** Controls above the close button — "open full page", "next record". */
+  actions?: ReactNode;
+  footer?: ReactNode;
+  /** Dim the page behind an overlay panel. Off by default: the list stays readable. */
+  scrim?: boolean;
+  closeOnOutsideClick?: boolean;
+  hideCloseButton?: boolean;
+  labels?: FlyoutLabels;
+  className?: string;
+  children: ReactNode;
+}
+/**
+ * Flyout — a detail panel that does not take the page away.
+ *
+ * Navigating from a list to a record and back costs the reader their scroll
+ * position, their filters and their place in the scan. A flyout keeps the list
+ * on screen and shows the record beside it, so comparing three rows is three
+ * clicks rather than six navigations.
+ *
+ * Deliberately **not** a modal: no focus trap, no `aria-modal`, no inert page.
+ * The list behind it is still the point, and a reader who tabs out of the panel
+ * to change a filter is doing the expected thing. Escape closes; focus returns
+ * to whatever opened it.
+ *
+ * @example
+ * ```tsx
+ * <Flyout open={Boolean(selected)} onClose={clear} title={selected?.name}>
+ *   <DescriptionList items={fields} />
+ * </Flyout>
+ * ```
+ */
+declare function Flyout({ open, onClose, title, description, type, side, size, actions, footer, scrim, closeOnOutsideClick, hideCloseButton, labels: customLabels, className, children }: FlyoutProps): import("react").JSX.Element | null;
+declare namespace Flyout {
+  var displayName: string;
+}
+//#endregion
+//#region src/lib/query/query-ast.d.ts
+/**
+ * A search query, as a value.
+ *
+ * Free-text search and a row of filter pickers answer different halves of the
+ * same question, and neither can express the other: a picker cannot say "not
+ * this", and a text box cannot say "this field, exactly". A parsed query is one
+ * thing that does both, and — because it is a value rather than a widget's
+ * internal state — it survives a URL, a saved view, and the trip to a server
+ * that has to turn it into a database filter.
+ *
+ * The grammar follows the one analytics tools have converged on (Elastic's
+ * `EuiSearchBar`, Kibana, GitHub's issue search), minus the parts that only
+ * make sense against a Lucene index:
+ *
+ *   error                  a term anywhere in the row
+ *   "connection reset"     a phrase, kept together
+ *   -health                a term that must not appear
+ *   path:/checkout         a field equal to a value
+ *   path:(/a or /b)        a field equal to any of several values
+ *   -status:200            a field that must not equal a value
+ *   status>=500            a comparison
+ *   path:*checkout*        the field contains this somewhere
+ *   utm_source:*           the field is present at all
+ *
+ * Clauses combine with AND; `or` only groups values inside one field. That is
+ * a deliberate ceiling: arbitrary boolean nesting reads worse than it queries,
+ * and every backend this targets can express the restricted form directly.
+ */
+/** How a field clause compares. */
+type QueryOperator = "eq" | "contains" | "gt" | "gte" | "lt" | "lte" | "exists";
+/** A bare or quoted word matched against the whole row. */
+interface QueryTermClause {
+  type: "term";
+  value: string;
+  negated: boolean;
+}
+/** A constraint on one named field. Several values read as "any of". */
+interface QueryFieldClause {
+  type: "field";
+  field: string;
+  operator: QueryOperator;
+  values: string[];
+  negated: boolean;
+}
+type QueryClause = QueryTermClause | QueryFieldClause;
+/** A parsed query: clauses combined with AND. */
+interface Query {
+  clauses: QueryClause[];
+}
+declare const EMPTY_QUERY: Query;
+/** Whether a query constrains anything at all. */
+declare function isEmptyQuery(query: Query | null | undefined): boolean;
+/** Add a clause unless an identical one is already there. */
+declare function addClause(query: Query, clause: QueryClause): Query;
+/**
+ * Constrain a field to a value — what a cell's "filter for this" action does.
+ *
+ * Applying the opposite of a constraint already present replaces it rather than
+ * adding it: `status:200` then "filter out 200" should read as one changed
+ * mind, not as a query that can never match.
+ */
+declare function withFieldValue(query: Query, field: string, value: string, options?: {
+  negated?: boolean;
+  operator?: QueryOperator;
+}): Query;
+/** Drop every clause naming `field`. */
+declare function withoutField(query: Query, field: string): Query;
+/** Drop the clause at `index`, for a removable chip. */
+declare function removeClause(query: Query, index: number): Query;
+/** Every field the query names, in the order they first appear. */
+declare function queryFields(query: Query): string[];
+/** The values a field is constrained to, if any — for showing a filter as active. */
+declare function fieldValues(query: Query, field: string): string[];
+/** What a "filter for / filter out" control on a value asks for. */
+interface QueryCellAction {
+  field: string;
+  value: string;
+  intent: "include" | "exclude";
+}
+/**
+ * Fold a cell action into the query.
+ *
+ * The pair of buttons on a log cell is the fastest path from "I noticed this
+ * value" to a filtered view, and the reason it works is that the result is a
+ * query the reader can then see, edit and share — not a hidden filter stack
+ * with its own rules.
+ */
+declare function applyCellAction(query: Query, action: QueryCellAction): Query;
+//#endregion
+//#region src/shells/query-bar.d.ts
+/** A field the query can constrain, offered as a completion. */
+interface QueryField {
+  name: string;
+  /** Shown beside the name — a type, a count, whatever tells them apart. */
+  hint?: string;
+  /** Known values, offered once the reader has typed `field:`. */
+  values?: string[];
+}
+/** Localized strings for the query bar. */
+interface QueryBarLabels {
+  placeholder?: string;
+  ariaLabel?: string;
+  clear?: string;
+  removeClause?: (clause: string) => string;
+  fieldsHeading?: string;
+  valuesHeading?: string;
+  syntaxHint?: ReactNode;
+}
+interface QueryBarProps {
+  value: Query;
+  onChange: (query: Query) => void;
+  /** Fields offered as completions, with their known values. */
+  fields?: QueryField[];
+  /** Show each clause as a removable chip below the input. */
+  showClauses?: boolean;
+  /** Commit on every keystroke instead of on Enter and blur. */
+  live?: boolean;
+  disabled?: boolean;
+  className?: string;
+  labels?: QueryBarLabels;
+}
+/**
+ * QueryBar — one control for "find this" and "only these".
+ *
+ * A search box and a row of filter pickers answer halves of the same question
+ * and neither can express the other, so people end up using both and holding
+ * the combination in their head. Typing the filter is what closes that: the
+ * whole question is one string, which means it can be read back, corrected in
+ * place, pasted to a colleague, and stored in a URL.
+ *
+ * The text is the source of truth while the reader is typing; the parsed query
+ * is committed on Enter or blur. Anything half-written parses to a plain term
+ * rather than an error, so the bar never argues with someone mid-word.
+ *
+ * @example
+ * ```tsx
+ * <QueryBar
+ *   value={query}
+ *   onChange={setQuery}
+ *   fields={[{ name: "path", values: ["/checkout", "/cart"] }]}
+ *   showClauses
+ * />
+ * ```
+ */
+declare function QueryBar({ value, onChange, fields, showClauses, live, disabled, className, labels: customLabels }: QueryBarProps): import("react").JSX.Element;
+declare namespace QueryBar {
+  var displayName: string;
+}
+//#endregion
 //#region src/shells/time-range-control.d.ts
 /** A named window offered in the quick-select list. */
 interface TimeRangePreset {
@@ -826,156 +1198,6 @@ declare const LogTable: <Row>(props: LogTableProps<Row> & {
   ref?: Ref<LogTableHandle>;
 }) => ReturnType<typeof LogTableInner>;
 //#endregion
-//#region src/lib/query/query-ast.d.ts
-/**
- * A search query, as a value.
- *
- * Free-text search and a row of filter pickers answer different halves of the
- * same question, and neither can express the other: a picker cannot say "not
- * this", and a text box cannot say "this field, exactly". A parsed query is one
- * thing that does both, and — because it is a value rather than a widget's
- * internal state — it survives a URL, a saved view, and the trip to a server
- * that has to turn it into a database filter.
- *
- * The grammar follows the one analytics tools have converged on (Elastic's
- * `EuiSearchBar`, Kibana, GitHub's issue search), minus the parts that only
- * make sense against a Lucene index:
- *
- *   error                  a term anywhere in the row
- *   "connection reset"     a phrase, kept together
- *   -health                a term that must not appear
- *   path:/checkout         a field equal to a value
- *   path:(/a or /b)        a field equal to any of several values
- *   -status:200            a field that must not equal a value
- *   status>=500            a comparison
- *   path:*checkout*        the field contains this somewhere
- *   utm_source:*           the field is present at all
- *
- * Clauses combine with AND; `or` only groups values inside one field. That is
- * a deliberate ceiling: arbitrary boolean nesting reads worse than it queries,
- * and every backend this targets can express the restricted form directly.
- */
-/** How a field clause compares. */
-type QueryOperator = "eq" | "contains" | "gt" | "gte" | "lt" | "lte" | "exists";
-/** A bare or quoted word matched against the whole row. */
-interface QueryTermClause {
-  type: "term";
-  value: string;
-  negated: boolean;
-}
-/** A constraint on one named field. Several values read as "any of". */
-interface QueryFieldClause {
-  type: "field";
-  field: string;
-  operator: QueryOperator;
-  values: string[];
-  negated: boolean;
-}
-type QueryClause = QueryTermClause | QueryFieldClause;
-/** A parsed query: clauses combined with AND. */
-interface Query {
-  clauses: QueryClause[];
-}
-declare const EMPTY_QUERY: Query;
-/** Whether a query constrains anything at all. */
-declare function isEmptyQuery(query: Query | null | undefined): boolean;
-/** Add a clause unless an identical one is already there. */
-declare function addClause(query: Query, clause: QueryClause): Query;
-/**
- * Constrain a field to a value — what a cell's "filter for this" action does.
- *
- * Applying the opposite of a constraint already present replaces it rather than
- * adding it: `status:200` then "filter out 200" should read as one changed
- * mind, not as a query that can never match.
- */
-declare function withFieldValue(query: Query, field: string, value: string, options?: {
-  negated?: boolean;
-  operator?: QueryOperator;
-}): Query;
-/** Drop every clause naming `field`. */
-declare function withoutField(query: Query, field: string): Query;
-/** Drop the clause at `index`, for a removable chip. */
-declare function removeClause(query: Query, index: number): Query;
-/** Every field the query names, in the order they first appear. */
-declare function queryFields(query: Query): string[];
-/** The values a field is constrained to, if any — for showing a filter as active. */
-declare function fieldValues(query: Query, field: string): string[];
-/** What a "filter for / filter out" control on a value asks for. */
-interface QueryCellAction {
-  field: string;
-  value: string;
-  intent: "include" | "exclude";
-}
-/**
- * Fold a cell action into the query.
- *
- * The pair of buttons on a log cell is the fastest path from "I noticed this
- * value" to a filtered view, and the reason it works is that the result is a
- * query the reader can then see, edit and share — not a hidden filter stack
- * with its own rules.
- */
-declare function applyCellAction(query: Query, action: QueryCellAction): Query;
-//#endregion
-//#region src/shells/query-bar.d.ts
-/** A field the query can constrain, offered as a completion. */
-interface QueryField {
-  name: string;
-  /** Shown beside the name — a type, a count, whatever tells them apart. */
-  hint?: string;
-  /** Known values, offered once the reader has typed `field:`. */
-  values?: string[];
-}
-/** Localized strings for the query bar. */
-interface QueryBarLabels {
-  placeholder?: string;
-  ariaLabel?: string;
-  clear?: string;
-  removeClause?: (clause: string) => string;
-  fieldsHeading?: string;
-  valuesHeading?: string;
-  syntaxHint?: ReactNode;
-}
-interface QueryBarProps {
-  value: Query;
-  onChange: (query: Query) => void;
-  /** Fields offered as completions, with their known values. */
-  fields?: QueryField[];
-  /** Show each clause as a removable chip below the input. */
-  showClauses?: boolean;
-  /** Commit on every keystroke instead of on Enter and blur. */
-  live?: boolean;
-  disabled?: boolean;
-  className?: string;
-  labels?: QueryBarLabels;
-}
-/**
- * QueryBar — one control for "find this" and "only these".
- *
- * A search box and a row of filter pickers answer halves of the same question
- * and neither can express the other, so people end up using both and holding
- * the combination in their head. Typing the filter is what closes that: the
- * whole question is one string, which means it can be read back, corrected in
- * place, pasted to a colleague, and stored in a URL.
- *
- * The text is the source of truth while the reader is typing; the parsed query
- * is committed on Enter or blur. Anything half-written parses to a plain term
- * rather than an error, so the bar never argues with someone mid-word.
- *
- * @example
- * ```tsx
- * <QueryBar
- *   value={query}
- *   onChange={setQuery}
- *   fields={[{ name: "path", values: ["/checkout", "/cart"] }]}
- *   showClauses
- * />
- * ```
- */
-declare function QueryBar({ value, onChange, fields, showClauses, live, disabled, className, labels: customLabels }: QueryBarProps): import("react").JSX.Element;
-declare namespace QueryBar {
-  var displayName: string;
-}
-//#endregion
 //#region src/shells/field-sidebar.d.ts
 /** One value a field takes, with how often. */
 interface FieldValueCount {
@@ -1066,5 +1288,4 @@ declare namespace FieldSidebar {
   var displayName: string;
 }
 //#endregion
-export { FailureListProps as $, LogTable as A, SidebarNav as At, TimeRangeControlLabels as B, CommandPaletteTrigger as Bt, withFieldValue as C, SettingsFormProps as Ct, LogColumnPriority as D, ContentTabsProps as Dt, LogColumn as E, ContentTabs as Et, TimeSeriesPanelLabels as F, StatusSelectProps as Ft, WorkflowCanvasProps as G, TimeRangePreset as H, CommandPalette as Ht, TimeSeriesPanelProps as I, SearchCombobox as It, KeyValueEditorLabels as J, WorkflowCanvasStep as K, DEFAULT_TIME_PRESETS as L, SearchComboboxProps as Lt, LogTableLabels as M, AppMenubar as Mt, LogTableProps as N, AppMenubarProps as Nt, LogDensity as O, EditorToolbar as Ot, TimeSeriesPanel as P, StatusSelect as Pt, FailureListLabels as Q, RefreshSetting as R, DashboardGrid as Rt, removeClause as S, SettingsForm as St, LogCellAction as T, FaqAccordionProps as Tt, WorkflowCanvas as U, CommandPaletteProps as Ut, TimeRangeControlProps as V, CommandPaletteTriggerProps as Vt, WorkflowCanvasConnection as W, KeyValueEntry as X, KeyValueEditorProps as Y, FailureList as Z, addClause as _, EnvPanelProps as _t, FieldValueCount as a, ToastProviderProps as at, isEmptyQuery as b, DeploymentTimeline as bt, QueryBarProps as c, useToast as ct, Query as d, DataTableProps as dt, NotificationToast as et, QueryCellAction as f, DomainTable as ft, QueryTermClause as g, EnvPanel as gt, QueryOperator as h, BranchSelectProps as ht, FieldSummary as i, ToastProvider as it, LogTableHandle as j, SidebarNavProps as jt, LogSort as k, EditorToolbarProps as kt, QueryField as l, ColumnDef as lt, QueryFieldClause as m, BranchSelect as mt, FieldSidebarLabels as n, ToastContextValue as nt, QueryBar as o, ToastVariant as ot, QueryClause as p, DomainTableProps as pt, KeyValueEditor as q, FieldSidebarProps as r, ToastMessage as rt, QueryBarLabels as s, toast as st, FieldSidebar as t, ToastAction as tt, EMPTY_QUERY as u, DataTable as ut, applyCellAction as v, ProjectSwitcher as vt, withoutField as w, FaqAccordion as wt, queryFields as x, DeploymentTimelineProps as xt, fieldValues as y, ProjectSwitcherProps as yt, TimeRangeControl as z, DashboardGridProps as zt };
-//# sourceMappingURL=field-sidebar-DWfJAJlx.d.ts.map
+export { EventTimelineItem as $, DashboardGridProps as $t, QueryCellAction as A, EnvPanel as At, removeClause as B, ContentTabs as Bt, TimeRangePreset as C, ColumnDef as Ct, QueryField as D, DomainTableProps as Dt, QueryBarProps as E, DomainTable as Et, addClause as F, DeploymentTimelineProps as Ft, FlyoutProps as G, SidebarNavProps as Gt, withoutField as H, EditorToolbar as Ht, applyCellAction as I, SettingsForm as It, ScoreBreakdown as J, StatusSelect as Jt, ScoreAxis as K, AppMenubar as Kt, fieldValues as L, SettingsFormProps as Lt, QueryFieldClause as M, ProjectSwitcher as Mt, QueryOperator as N, ProjectSwitcherProps as Nt, EMPTY_QUERY as O, BranchSelect as Ot, QueryTermClause as P, DeploymentTimeline as Pt, EventTimelineGroup as Q, DashboardGrid as Qt, isEmptyQuery as R, FaqAccordion as Rt, TimeRangeControlProps as S, useToast as St, QueryBarLabels as T, DataTableProps as Tt, Flyout as U, EditorToolbarProps as Ut, withFieldValue as V, ContentTabsProps as Vt, FlyoutLabels as W, SidebarNav as Wt, ScoreBreakdownProps as X, SearchCombobox as Xt, ScoreBreakdownLabels as Y, StatusSelectProps as Yt, EventTimeline as Z, SearchComboboxProps as Zt, TimeSeriesPanelProps as _, ToastMessage as _t, FieldValueCount as a, WorkflowCanvasProps as at, TimeRangeControl as b, ToastVariant as bt, LogColumnPriority as c, KeyValueEditorLabels as ct, LogTable as d, FailureList as dt, CommandPaletteTrigger as en, EventTimelineLabels as et, LogTableHandle as f, FailureListLabels as ft, TimeSeriesPanelLabels as g, ToastContextValue as gt, TimeSeriesPanel as h, ToastAction as ht, FieldSummary as i, WorkflowCanvasConnection as it, QueryClause as j, EnvPanelProps as jt, Query as k, BranchSelectProps as kt, LogDensity as l, KeyValueEditorProps as lt, LogTableProps as m, NotificationToast as mt, FieldSidebarLabels as n, CommandPalette as nn, EventTimelineTone as nt, LogCellAction as o, WorkflowCanvasStep as ot, LogTableLabels as p, FailureListProps as pt, ScoreBand as q, AppMenubarProps as qt, FieldSidebarProps as r, CommandPaletteProps as rn, WorkflowCanvas as rt, LogColumn as s, KeyValueEditor as st, FieldSidebar as t, CommandPaletteTriggerProps as tn, EventTimelineProps as tt, LogSort as u, KeyValueEntry as ut, DEFAULT_TIME_PRESETS as v, ToastProvider as vt, QueryBar as w, DataTable as wt, TimeRangeControlLabels as x, toast as xt, RefreshSetting as y, ToastProviderProps as yt, queryFields as z, FaqAccordionProps as zt };