@reopt-ai/opt-ui 1.6.0 → 1.7.0

package/dist/field-sidebar-BTZCBviA.d.cts

@@ -0,0 +1,1031 @@
+
+import { A as StatCard, C as MenuDef, D as ProjectDef, E as NavItemDef, L as ToolbarButtonDef, S as FormFieldDef, d as CommandDef, f as DeploymentStep, j as TabDef, k as SelectOption, m as EnvGroupDef, n as BranchDef, p as DomainDef, v as FailureItem, y as FaqItem } from "./types-D0FlcYnM.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";
+//#region src/shells/command-palette.d.ts
+/** Localized labels for the command palette component. */
+interface CommandPaletteLabels {
+  title?: string;
+  description?: string;
+  input?: string;
+  placeholder?: string;
+  list?: string;
+  empty?: ReactNode;
+  escape?: string;
+}
+/** Props for the command palette component. */
+interface CommandPaletteProps {
+  commands: Omit<CommandDef, "action">[];
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onSelect?: (command: Omit<CommandDef, "action">) => void;
+  /** Render inline (no dialog overlay). */
+  inline?: boolean;
+  labels?: CommandPaletteLabels;
+  footer?: ReactNode;
+  empty?: ReactNode;
+  inputTrailing?: ReactNode;
+  className?: string;
+}
+/** Renders the command palette component. */
+declare function CommandPalette({ commands, open, onOpenChange, onSelect, inline, labels, footer, empty, inputTrailing, className }: CommandPaletteProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/shells/command-palette-trigger.d.ts
+/** Props for the command palette trigger component. */
+interface CommandPaletteTriggerProps {
+  commands: Omit<CommandDef, "action">[];
+  onSelect?: (command: Omit<CommandDef, "action">) => void;
+  labels?: CommandPaletteTriggerLabels;
+}
+/** Localized labels for the command palette trigger component. */
+type CommandPaletteTriggerLabels = CommandPaletteLabels;
+/** Renders the command palette trigger component. */
+declare function CommandPaletteTrigger({ commands, onSelect, labels }: CommandPaletteTriggerProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/shells/dashboard-grid.d.ts
+/** Localized labels for the dashboard grid component. */
+interface DashboardGridLabels {
+  ariaLabel?: string;
+}
+/** Props for the dashboard grid component. */
+interface DashboardGridProps {
+  stats: StatCard[];
+  columns?: number;
+  labels?: DashboardGridLabels;
+}
+/** Renders the dashboard grid component. */
+declare function DashboardGrid({ stats, columns, labels: customLabels }: DashboardGridProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/search-combobox.d.ts
+/** Localized labels for the search combobox component. */
+interface SearchComboboxLabels {
+  noResults?: string;
+  loading?: string;
+}
+/** Props for the search combobox component. */
+interface SearchComboboxProps {
+  items: string[];
+  placeholder?: string;
+  label?: string;
+  onSelect?: (item: string) => void;
+  labels?: SearchComboboxLabels;
+  /** Enable async search mode */
+  async?: boolean;
+  /** Async search callback (used when async=true) */
+  onSearch?: (query: string) => Promise<string[]>;
+  /** Debounce ms for async search */
+  debounceMs?: number;
+}
+/** Renders the search combobox component. */
+declare function SearchCombobox({ items, placeholder, label, onSelect, labels: customLabels, async: isAsync, onSearch, debounceMs }: SearchComboboxProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/status-select.d.ts
+/** Props for the status select component. */
+interface StatusSelectProps {
+  options: SelectOption[];
+  value?: string;
+  onChange?: (value: string) => void;
+  label?: string;
+  labels?: StatusSelectLabels;
+}
+/** Localized labels for the status select component. */
+interface StatusSelectLabels {
+  selectLabel?: string;
+  emptyMessage?: string;
+}
+/** Renders the status select component. */
+declare function StatusSelect({ options, value: controlledValue, onChange, label, labels: customLabels }: StatusSelectProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/app-menubar.d.ts
+/** Props for the app menubar component. */
+interface AppMenubarProps {
+  menus: MenuDef[];
+  labels?: AppMenubarLabels;
+}
+/** Localized labels for the app menubar component. */
+interface AppMenubarLabels {
+  ariaLabel?: string;
+}
+/** Renders the app menubar component. */
+declare function AppMenubar({ menus, labels: customLabels }: AppMenubarProps): import("react").JSX.Element | null;
+declare namespace AppMenubar {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/sidebar-nav.d.ts
+/** Localized labels for the sidebar nav component. */
+interface SidebarNavLabels {
+  ariaLabel?: string;
+}
+/** Props for the sidebar nav component. */
+interface SidebarNavProps {
+  items: NavItemDef[];
+  labels?: SidebarNavLabels;
+}
+/** Renders the sidebar nav component. */
+declare function SidebarNav({ items, labels: customLabels }: SidebarNavProps): import("react").JSX.Element | null;
+//#endregion
+//#region src/shells/editor-toolbar.d.ts
+/** Localized labels for the editor toolbar component. */
+interface EditorToolbarLabels {
+  ariaLabel?: string;
+}
+/** Props for the editor toolbar component. */
+interface EditorToolbarProps {
+  buttons: ToolbarButtonDef[];
+  onAction?: (id: string) => void;
+  activeButtons?: string[];
+  labels?: EditorToolbarLabels;
+}
+/** Renders the editor toolbar component. */
+declare function EditorToolbar({ buttons, onAction, activeButtons, labels: customLabels }: EditorToolbarProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/content-tabs.d.ts
+/** Localized labels for the content tabs component. */
+interface ContentTabsLabels {
+  ariaLabel?: string;
+  emptyMessage?: string;
+}
+/** Props for the content tabs component. */
+interface ContentTabsProps {
+  tabs: TabDef[];
+  defaultTabId?: string;
+  labels?: ContentTabsLabels;
+}
+/** Renders the content tabs component. */
+declare function ContentTabs({ tabs, defaultTabId, labels: customLabels }: ContentTabsProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/faq-accordion.d.ts
+/** Localized labels for the faq accordion component. */
+interface FaqAccordionLabels {
+  ariaLabel?: string;
+  emptyMessage?: string;
+}
+/** Props for the faq accordion component. */
+interface FaqAccordionProps {
+  items: FaqItem[];
+  labels?: FaqAccordionLabels;
+}
+/** Renders the faq accordion component. */
+declare function FaqAccordion({ items, labels: customLabels }: FaqAccordionProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/settings-form.d.ts
+/** Localized labels for the settings form component. */
+interface SettingsFormLabels {
+  formAriaLabel?: string;
+  submitButton?: string;
+  successMessage?: string;
+}
+/** Props for the settings form component. */
+interface SettingsFormProps {
+  fields: FormFieldDef[];
+  onSubmit?: (values: Record<string, unknown>) => void;
+  labels?: SettingsFormLabels;
+}
+/** Renders the settings form component. */
+declare function SettingsForm({ fields, onSubmit, labels: customLabels }: SettingsFormProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/deployment-timeline.d.ts
+/** Props for the deployment timeline component. */
+interface DeploymentTimelineProps {
+  steps: DeploymentStep[];
+  title?: string;
+}
+/** Renders the deployment timeline component. */
+declare function DeploymentTimeline({ steps, title }: DeploymentTimelineProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/project-switcher.d.ts
+/** Props for the project switcher component. */
+interface ProjectSwitcherProps {
+  projects: ProjectDef[];
+  value?: string;
+  onChange?: (id: string) => void;
+  placeholder?: string;
+}
+/** Renders the project switcher component. */
+declare function ProjectSwitcher({ projects, value, onChange, placeholder }: ProjectSwitcherProps): import("react").JSX.Element;
+declare namespace ProjectSwitcher {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/env-panel.d.ts
+/** Localized labels for the env panel component. */
+interface EnvPanelLabels {
+  varCount?: (count: number) => string;
+  envVarsLabel?: (env: string) => string;
+  secretBadge?: string;
+}
+/** Props for the env panel component. */
+interface EnvPanelProps {
+  groups: EnvGroupDef[];
+  labels?: EnvPanelLabels;
+}
+/** Renders the env panel component. */
+declare function EnvPanel({ groups, labels: customLabels }: EnvPanelProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/branch-select.d.ts
+/** Localized labels for the branch select component. */
+interface BranchSelectLabels {
+  selectLabel?: string;
+  emptySelectionLabel?: string;
+  emptyMessage?: string;
+  defaultBadge?: string;
+}
+/** Props for the branch select component. */
+interface BranchSelectProps {
+  branches: BranchDef[];
+  value?: string;
+  onChange?: (name: string) => void;
+  label?: string;
+  labels?: BranchSelectLabels;
+}
+/** Renders the branch select component. */
+declare function BranchSelect({ branches, value: controlledValue, onChange, label, labels: customLabels }: BranchSelectProps): import("react").JSX.Element;
+declare namespace BranchSelect {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/domain-table.d.ts
+/** Localized labels for the domain table component. */
+interface DomainTableLabels {
+  domain?: string;
+  status?: string;
+  ssl?: string;
+  redirect?: string;
+  added?: string;
+  emptyMessage?: string;
+}
+/** Props for the domain table component. */
+interface DomainTableProps {
+  domains: DomainDef[];
+  title?: string;
+  labels?: DomainTableLabels;
+}
+/** Renders the domain table component. */
+declare function DomainTable({ domains, title, labels: customLabels }: DomainTableProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/data-table.d.ts
+/**
+ * Column definition for DataTable.
+ * `accessor` can be a property key for simple lookups or a render function
+ * for computed/complex cells.
+ */
+interface ColumnDef<T> {
+  id: string;
+  header: string;
+  accessor: keyof T | ((row: T) => ReactNode);
+  width?: string;
+  align?: "left" | "center" | "right";
+  sortable?: boolean;
+  /** Show an inline progress bar in the cell. Return a 0-1 ratio. */
+  bar?: (row: T) => number;
+  /** Bar color class (default: "bg-accent") */
+  barColor?: string;
+}
+/** Props for the data table component. */
+interface DataTableProps<T> {
+  data: T[];
+  columns: ColumnDef<T>[];
+  keyExtractor: (row: T) => string;
+  title?: string;
+  onRowClick?: (row: T) => void;
+  emptyMessage?: string;
+  /** Highlight a single row by its key */
+  activeRowId?: string;
+  /** Enable column sorting */
+  sortable?: boolean;
+  /** Enable row selection with checkboxes */
+  selectable?: boolean;
+  selectedKeys?: string[];
+  onSelectionChange?: (keys: string[]) => void;
+  /** Enable expandable rows */
+  expandable?: boolean;
+  renderExpanded?: (row: T) => ReactNode;
+  /** Enable pagination */
+  pageSize?: number;
+  /** Sticky table header */
+  stickyHeader?: boolean;
+  /** Enable column resizing via drag handle */
+  resizableColumns?: boolean;
+  /** External (server-side) sort callback */
+  onSort?: (columnId: string, direction: "asc" | "desc" | null) => void;
+  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;
+//#endregion
+//#region src/shells/notification-toast.d.ts
+/** Defines the toast action shape. */
+interface ToastAction {
+  label: string;
+  onClick: () => void;
+}
+/** Toast severity. */
+type ToastVariant = "info" | "success" | "warning" | "error";
+/** Defines the toast message shape. */
+interface ToastMessage {
+  id: string;
+  variant: ToastVariant;
+  title?: string;
+  message: string;
+  duration?: number;
+  actions?: ToastAction[];
+}
+/** Options accepted by the imperative `toast()` API. */
+interface ToastOptions {
+  variant?: ToastVariant;
+  title?: string;
+  message: string;
+  duration?: number;
+  actions?: ToastAction[];
+}
+/** Defines the toast context value shape. */
+interface ToastContextValue {
+  toasts: ToastMessage[];
+  addToast: (toast: Omit<ToastMessage, "id">) => string;
+  removeToast: (id: string) => void;
+}
+/**
+ * Imperative toast API. Call from anywhere (no hook required):
+ * `toast.success("Saved")`, `toast.error("Failed", { title: "Oops" })`,
+ * `toast.dismiss(id)`, `toast.clear()`. Requires a mounted `ToastProvider`.
+ */
+declare const toast: ((options: ToastOptions) => string) & {
+  info: (message: string, options?: Omit<ToastOptions, "message" | "variant">) => string;
+  success: (message: string, options?: Omit<ToastOptions, "message" | "variant">) => string;
+  warning: (message: string, options?: Omit<ToastOptions, "message" | "variant">) => string;
+  error: (message: string, options?: Omit<ToastOptions, "message" | "variant">) => string;
+  dismiss: (id: string) => void;
+  clear: () => void;
+};
+/** Props for the toast provider component. */
+interface ToastProviderProps {
+  children: ReactNode;
+  position?: "top-right" | "top-left" | "bottom-right" | "bottom-left";
+  defaultDuration?: number;
+  stackLimit?: number;
+}
+/** Renders the toast provider component. */
+declare function ToastProvider({ children, position, defaultDuration, stackLimit }: ToastProviderProps): import("react").JSX.Element;
+/** Provides toast. */
+declare function useToast(): ToastContextValue;
+interface NotificationToastProps {
+  toast: ToastMessage;
+  onDismiss: () => void;
+  /** Falls back here when the toast itself sets no duration. */
+  defaultDuration?: number;
+}
+/** Renders the notification toast component. */
+declare function NotificationToast({ toast, onDismiss, defaultDuration }: NotificationToastProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/failure-list.d.ts
+interface TimeAgoLabels {
+  justNow: string;
+  minutesAgo: string;
+  hoursAgo: string;
+  daysAgo: string;
+}
+/** Localized labels for the failure list component. */
+interface FailureListLabels {
+  title?: string;
+  emptyMessage?: string;
+  moreItems?: string;
+  severityLabels?: Partial<Record<"critical" | "error" | "warning", string>>;
+  timeAgo?: Partial<TimeAgoLabels>;
+}
+/** Props for the failure list component. */
+interface FailureListProps {
+  failures: FailureItem[];
+  title?: string;
+  maxItems?: number;
+  /** Group failures by `group` field */
+  grouped?: boolean;
+  onFailureClick?: (failure: FailureItem) => void;
+  onShowMore?: () => void;
+  labels?: FailureListLabels;
+  locale?: string;
+  loading?: boolean;
+  renderActions?: (failure: FailureItem) => ReactNode;
+  className?: string;
+}
+/** Renders the failure list component. */
+declare function FailureList({ failures, title, maxItems, grouped, onFailureClick, onShowMore, labels: customLabels, locale, loading, renderActions, className }: FailureListProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/key-value-editor.d.ts
+/** Defines the key value entry shape. */
+interface KeyValueEntry {
+  id: string;
+  key: string;
+  value: string;
+  isSecret?: boolean;
+}
+/** Localized labels for the key value editor component. */
+interface KeyValueEditorLabels {
+  keyPlaceholder?: string;
+  valuePlaceholder?: string;
+  addButton?: string;
+  removeAriaLabel?: string;
+  toggleSecretAriaLabel?: string;
+  emptyMessage?: string;
+}
+/** Props for the key value editor component. */
+interface KeyValueEditorProps {
+  /** Current entries (controlled) */
+  value?: KeyValueEntry[];
+  /** Initial entries (uncontrolled) */
+  defaultValue?: KeyValueEntry[];
+  /** Called when entries change */
+  onChange?: (entries: KeyValueEntry[]) => void;
+  /** Allow toggling secret/password visibility */
+  showSecretToggle?: boolean;
+  /** Maximum number of entries allowed */
+  maxEntries?: number;
+  /** Whether entries are read-only */
+  readOnly?: boolean;
+  /** Custom labels for i18n */
+  labels?: KeyValueEditorLabels;
+  /** Render custom actions per entry */
+  renderActions?: (entry: KeyValueEntry, index: number) => ReactNode;
+  /** Validate key on change. Return error message or undefined. */
+  validateKey?: (key: string, entries: KeyValueEntry[]) => string | undefined;
+  className?: string;
+}
+/** Renders the key value editor component. */
+declare function KeyValueEditor({ value: controlledValue, defaultValue, onChange, showSecretToggle, maxEntries, readOnly, labels: customLabels, renderActions, validateKey, className }: KeyValueEditorProps): import("react").JSX.Element;
+//#endregion
+//#region src/shells/workflow-canvas.d.ts
+/** Defines the workflow canvas step shape. */
+interface WorkflowCanvasStep {
+  id: string;
+  title: string;
+  row: number;
+  col: number;
+  status?: "idle" | "running" | "success" | "error";
+}
+/** Defines the workflow canvas connection shape. */
+interface WorkflowCanvasConnection {
+  from: string;
+  to: string;
+  label?: string;
+}
+/** Props for the workflow canvas component. */
+interface WorkflowCanvasProps {
+  steps: WorkflowCanvasStep[];
+  connections?: WorkflowCanvasConnection[];
+  rows?: number;
+  cols?: number;
+  cellSize?: number;
+  gap?: number;
+  title?: string;
+  emptyMessage?: string;
+  selectedStepId?: string;
+  onSelectStep?: (step: WorkflowCanvasStep) => void;
+  onStepMove?: (stepId: string, row: number, col: number) => void;
+  renderStep?: (step: WorkflowCanvasStep, selected: boolean) => React.ReactNode;
+  className?: string;
+}
+/** Renders the workflow canvas component. */
+declare function WorkflowCanvas({ steps, connections, rows, cols, cellSize, gap, title, emptyMessage, selectedStepId, onSelectStep, onStepMove, renderStep, className }: WorkflowCanvasProps): React.JSX.Element;
+declare namespace WorkflowCanvas {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/time-range-control.d.ts
+/** A named window offered in the quick-select list. */
+interface TimeRangePreset {
+  label: string;
+  range: TimeRange$1;
+}
+/** How often the control asks its owner to re-query. */
+interface RefreshSetting {
+  /** Milliseconds. `0` means off. */
+  interval: number;
+  paused: boolean;
+}
+/** Localized strings for the time range control. */
+interface TimeRangeControlLabels {
+  trigger?: string;
+  invalid?: string;
+  last?: (duration: string) => string;
+  next?: (duration: string) => string;
+  quickSelect?: string;
+  apply?: string;
+  update?: string;
+  refresh?: string;
+  commonlyUsed?: string;
+  recentlyUsed?: string;
+  start?: string;
+  end?: string;
+  startHint?: string;
+  autoRefresh?: string;
+  autoRefreshOff?: string;
+  every?: (duration: string) => string;
+  previous?: string;
+  nextWindow?: string;
+  zoomIn?: string;
+  zoomOut?: string;
+  /** e.g. "This day" for a window snapped to a calendar unit. */
+  thisUnit?: (unit: string) => string;
+  units?: Partial<Record<TimeUnitKey, string>>;
+}
+/** Units the control can name. `s` only shows up in a parsed expression. */
+type TimeUnitKey = "s" | "m" | "h" | "d" | "w" | "M" | "y";
+/** Props for the time range control. */
+interface TimeRangeControlProps {
+  value: TimeRange$1;
+  onChange: (range: TimeRange$1) => void;
+  /** Named windows shown in the popover. */
+  presets?: TimeRangePreset[];
+  /** Windows the user picked before, newest first. Owned by the caller. */
+  recentRanges?: TimeRangePreset[];
+  /** IANA zone used for rounding and display. */
+  timeZone?: string;
+  locale?: string;
+  /**
+   * Hold edits until the user commits them. A queried window is expensive;
+   * typing "now-3" should not fire three requests.
+   */
+  showUpdateButton?: boolean;
+  /** Step the window back and forth, and widen or narrow it. */
+  showWindowButtons?: boolean;
+  /** Zoom-out step, as a fraction of the current width. */
+  zoomFactor?: number;
+  refresh?: RefreshSetting;
+  onRefreshChange?: (setting: RefreshSetting) => void;
+  /** Called by the refresh button and by each auto-refresh tick. */
+  onRefresh?: () => void | Promise<unknown>;
+  isLoading?: boolean;
+  disabled?: boolean;
+  className?: string;
+  labels?: TimeRangeControlLabels;
+  "aria-label"?: string;
+}
+/**
+ * TimeRangeControl — the window as an expression, not two frozen instants.
+ *
+ * Holding `{ from: "now-7d", to: "now" }` instead of a resolved pair is what
+ * makes a saved board, a shared link and an auto-refresh timer all mean the
+ * same thing tomorrow that they mean today. Around that sit the moves people
+ * actually make on a chart: jump to a named window, step the same width back
+ * and forth to compare, widen when the interesting thing is just off screen,
+ * and let it re-query on a timer while they watch.
+ *
+ * @example
+ * ```tsx
+ * const [range, setRange] = useState<TimeRange>({ from: "now-7d", to: "now" });
+ *
+ * <TimeRangeControl
+ *   value={range}
+ *   onChange={setRange}
+ *   timeZone="Asia/Seoul"
+ *   showWindowButtons
+ *   onRefresh={() => refetch()}
+ * />
+ * ```
+ */
+declare function TimeRangeControl({ value, onChange, presets, recentRanges, timeZone, locale, showUpdateButton, showWindowButtons, zoomFactor, refresh, onRefreshChange, onRefresh, isLoading, disabled, className, labels: customLabels, "aria-label": ariaLabel }: TimeRangeControlProps): import("react").JSX.Element;
+declare namespace TimeRangeControl {
+  var displayName: string;
+}
+/**
+ * The windows most analytics tools open with. Exported so a caller gets a
+ * sensible list without inventing date math of their own.
+ */
+declare const DEFAULT_TIME_PRESETS: TimeRangePreset[];
+//#endregion
+//#region src/shells/time-series-panel.d.ts
+/** Localized strings for the time series panel. */
+interface TimeSeriesPanelLabels {
+  back?: string;
+  legend?: string;
+  control?: TimeRangeControlLabels;
+}
+/** Props for the time series panel. */
+interface TimeSeriesPanelProps {
+  title?: ReactNode;
+  description?: ReactNode;
+  /** Extra controls for the header's right side. */
+  actions?: ReactNode;
+  data: TimeSeriesPoint[];
+  series: TimeSeriesDef[];
+  /** The queried window. Also pins the chart's axis. */
+  range: TimeRange;
+  onRangeChange: (range: TimeRange) => void;
+  granularity?: TimeGranularity | "auto";
+  timeZone?: string;
+  locale?: string;
+  /** Render the built-in time range control in the header. */
+  showRangeControl?: boolean;
+  presets?: TimeRangePreset[];
+  recentRanges?: TimeRangePreset[];
+  refresh?: RefreshSetting;
+  onRefreshChange?: (setting: RefreshSetting) => void;
+  onRefresh?: () => void | Promise<unknown>;
+  /** Legend entries can be clicked to hide a series. */
+  toggleableLegend?: boolean;
+  annotations?: TimeSeriesAnnotation[];
+  isLoading?: boolean;
+  height?: number;
+  className?: string;
+  /** Anything the chart itself accepts, for the cases this shell does not name. */
+  chartProps?: Omit<TimeSeriesChartProps, "data" | "series" | "from" | "to" | "granularity" | "timeZone" | "locale">;
+  labels?: TimeSeriesPanelLabels;
+  "aria-label"?: string;
+}
+/**
+ * TimeSeriesPanel — a chart you can steer.
+ *
+ * The point of putting the control and the chart in one component is the
+ * loop between them: drag across the plot and the window narrows to what you
+ * dragged, which re-queries, which redraws the axis you just picked. That
+ * only works if someone owns the step back out again — so zoom keeps a
+ * history, and the header offers the way back rather than leaving the reader
+ * to retype the range they came from.
+ *
+ * @example
+ * ```tsx
+ * const [range, setRange] = useState<TimeRange>({ from: "now-7d", to: "now" });
+ *
+ * <TimeSeriesPanel
+ *   title="Sessions"
+ *   data={points}
+ *   series={[{ dataKey: "sessions", name: "Sessions" }]}
+ *   range={range}
+ *   onRangeChange={setRange}
+ *   onRefresh={() => refetch()}
+ *   toggleableLegend
+ * />
+ * ```
+ */
+declare function TimeSeriesPanel({ title, description, actions, data, series, range, onRangeChange, granularity, timeZone, locale, showRangeControl, presets, recentRanges, refresh, onRefreshChange, onRefresh, toggleableLegend, annotations, isLoading, height, className, chartProps, labels: customLabels, "aria-label": ariaLabel }: TimeSeriesPanelProps): import("react").JSX.Element;
+declare namespace TimeSeriesPanel {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/log-table.d.ts
+/**
+ * When a column gives up its space.
+ *
+ * Named steps rather than arbitrary widths because the breakpoints are
+ * container queries compiled by Tailwind, which cannot see a value computed at
+ * runtime. They are also the honest unit here: what matters is the order
+ * columns drop in, not the pixel each one leaves at.
+ */
+type LogColumnPriority = "always" | "sm" | "md" | "lg" | "xl";
+/** One column of the log. */
+interface LogColumn<Row> {
+  id: string;
+  header: ReactNode;
+  /**
+   * The field this column reads, as the query language names it. Set it and the
+   * cell offers "filter for / filter out"; leave it off for a derived column
+   * that no filter could express.
+   */
+  field?: string;
+  /** CSS width. Omit on exactly one column to let it take the slack. */
+  width?: string;
+  priority?: LogColumnPriority;
+  align?: "left" | "right";
+  mono?: boolean;
+  sortable?: boolean;
+  /** The cell's text — also what a cell action filters on. */
+  value: (row: Row) => string | number | null | undefined;
+  /** Richer cell content. Falls back to `value`. */
+  render?: (row: Row) => ReactNode;
+  /**
+   * Draw a colour marker before the value, hashed from the value itself so the
+   * same one lands on the same hue in every session.
+   */
+  marker?: boolean;
+}
+/** Which column the rows are ordered by. */
+interface LogSort {
+  columnId: string;
+  direction: "asc" | "desc";
+}
+/** What a cell action asks the caller to do. */
+interface LogCellAction {
+  field: string;
+  value: string;
+  intent: "include" | "exclude";
+}
+type LogDensity = "compact" | "normal" | "comfortable";
+/** Localized strings for the log table. */
+interface LogTableLabels {
+  listLabel?: string;
+  loadingMore?: string;
+  endOfResults?: string;
+  filterFor?: (value: string) => string;
+  filterOut?: (value: string) => string;
+  sortAscending?: string;
+  sortDescending?: string;
+}
+interface LogTableProps<Row> {
+  rows: Row[];
+  columns: LogColumn<Row>[];
+  getRowId: (row: Row) => string;
+  selectedId?: string | null;
+  onSelect?: (id: string) => void;
+  /** Fetch the next page. Called once when the viewport nears the end. */
+  onLoadMore?: () => void;
+  hasMore?: boolean;
+  loadingMore?: boolean;
+  /**
+   * Rows arrive at the top while the reader is scrolled down — a live tail.
+   * Turning this on holds their place when that happens and reports whether
+   * they are pinned to the newest row.
+   */
+  prepending?: boolean;
+  onFollowChange?: (following: boolean) => void;
+  /** Highlight a row once, for entries that just arrived. */
+  isNew?: (row: Row) => boolean;
+  sort?: LogSort | null;
+  onSortChange?: (sort: LogSort) => void;
+  /** Offer "filter for / filter out" on cells whose column names a field. */
+  onCellAction?: (action: LogCellAction) => void;
+  density?: LogDensity;
+  showHeader?: boolean;
+  emptyState?: ReactNode;
+  labels?: LogTableLabels;
+  className?: string;
+}
+interface LogTableHandle {
+  /** Jump to the newest row. */
+  scrollToTop: () => void;
+  /** Bring a row into view, leaving the scroll alone if it already is. */
+  revealRow: (id: string) => void;
+}
+/**
+ * LogTable — a windowed table for entries that keep arriving.
+ *
+ * Written by hand rather than delegated to a data grid for the two things a log
+ * needs that a grid does not: rows are inserted at the *top* while the reader
+ * is partway down, which needs a scroll correction applied before paint, and
+ * "am I at the newest row?" has to be answerable from the scroll container to
+ * decide whether to follow the tail or hold position.
+ *
+ * What it takes from a data grid is the part readers actually reach for:
+ * columns are data, so a caller can let people add, drop and reorder them; a
+ * cell offers to filter for or against its own value; and density is a setting
+ * rather than a constant.
+ *
+ * @example
+ * ```tsx
+ * <LogTable
+ *   rows={rows}
+ *   getRowId={(row) => row.id}
+ *   columns={[
+ *     { id: "time", header: "Time", width: "9rem", mono: true, value: (r) => r.time },
+ *     { id: "name", header: "Event", width: "14rem", field: "name", marker: true, value: (r) => r.name },
+ *     { id: "path", header: "Path", field: "path", value: (r) => r.path },
+ *   ]}
+ *   onCellAction={(action) => setQuery(applyCellAction(query, action))}
+ * />
+ * ```
+ */
+declare function LogTableInner<Row>({ rows, columns, getRowId, selectedId, onSelect, onLoadMore, hasMore, loadingMore, prepending, onFollowChange, isNew, sort, onSortChange, onCellAction, density, showHeader, emptyState, labels: customLabels, className }: LogTableProps<Row>, ref: Ref<LogTableHandle>): import("react").JSX.Element;
+/**
+ * LogTable — see {@link LogTableInner}.
+ *
+ * The cast preserves the row generic through `forwardRef`, which otherwise
+ * widens it to its constraint and takes the column callbacks' types with it.
+ */
+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 {
+  value: string;
+  count: number;
+  /** Share of the sampled rows, 0–1. Derived from counts when omitted. */
+  share?: number;
+}
+/** A field the reader can inspect, filter on, or put in the table. */
+interface FieldSummary {
+  name: string;
+  /** Shown beside the name — "string", "number", a source, whatever separates them. */
+  type?: string;
+  /** Grouping header. Fields with the same group are listed together. */
+  group?: string;
+  /** True when the field is currently a column. */
+  inTable?: boolean;
+  /** False for fields that exist but cannot be a column (a nested object, say). */
+  columnable?: boolean;
+}
+/** Localized strings for the field sidebar. */
+interface FieldSidebarLabels {
+  heading?: string;
+  searchPlaceholder?: string;
+  searchLabel?: string;
+  empty?: string;
+  addColumn?: (field: string) => string;
+  removeColumn?: (field: string) => string;
+  filterFor?: (value: string) => string;
+  filterOut?: (value: string) => string;
+  topValues?: (count: number) => string;
+  noValues?: string;
+  loadingValues?: string;
+  otherGroup?: string;
+}
+interface FieldSidebarProps {
+  fields: FieldSummary[];
+  /** The field whose values are open. Controlled so the caller can fetch them. */
+  expandedField?: string | null;
+  onExpandedFieldChange?: (field: string | null) => void;
+  /** Values for the expanded field. The caller fetches them on expansion. */
+  values?: FieldValueCount[];
+  valuesLoading?: boolean;
+  /** Rows the counts were taken over, for the reader to judge the sample by. */
+  sampledRows?: number;
+  onToggleColumn?: (field: string, next: boolean) => void;
+  onFilter?: (field: string, value: string, intent: "include" | "exclude") => void;
+  header?: ReactNode;
+  className?: string;
+  labels?: FieldSidebarLabels;
+}
+/**
+ * FieldSidebar — what is in this data, and what does it contain.
+ *
+ * Without it, a log answers only the questions you already knew to ask: you can
+ * filter on `utm_source` if you remember it exists, and you can read a value if
+ * you open a row and scroll to it. Listing the fields turns that around — the
+ * data tells the reader what is available — and the value counts answer the
+ * question that actually follows ("mostly which?") before they have to run a
+ * query to find out.
+ *
+ * Three actions live here because they are the three things people do next:
+ * put the field in the table, keep only rows with a value, drop rows with it.
+ *
+ * @example
+ * ```tsx
+ * <FieldSidebar
+ *   fields={fields}
+ *   expandedField={openField}
+ *   onExpandedFieldChange={setOpenField}
+ *   values={valuesQuery.data}
+ *   valuesLoading={valuesQuery.isLoading}
+ *   onToggleColumn={(field, next) => setColumns(...)}
+ *   onFilter={(field, value, intent) => setQuery(applyCellAction(query, { field, value, intent }))}
+ * />
+ * ```
+ */
+declare function FieldSidebar({ fields, expandedField, onExpandedFieldChange, values, valuesLoading, sampledRows, onToggleColumn, onFilter, header, className, labels: customLabels }: FieldSidebarProps): import("react").JSX.Element;
+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-BTZCBviA.d.cts.map