@reopt-ai/opt-ui 1.12.5 → 1.13.0

package/dist/{field-sidebar-YaWHfLLW.d.ts → field-sidebar-Dz7J4ett.d.ts}

@@ -1,5 +1,5 @@
 
-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.js";
+import { A as DomainDef, B as MenuDef, F as FailureItem, I as FaqItem, J as TabDef, K as SelectOption, O as CommandDef, U as NavItemDef, W as ProjectDef, _ as DateRangePreset, a as FieldDataType, et as ToolbarButtonDef, j as EnvGroupDef, k as DeploymentStep, m as DateRange, q as StatCard, r as TruncationSide, y as BranchDef, z as FormFieldDef } from "./text-truncate-eMzvU_7k.js";
 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";
@@ -538,6 +538,828 @@ declare namespace WorkflowCanvas {
   var displayName: string;
 }
 //#endregion
+//#region src/shells/query-results-table.d.ts
+/** A result column: its name and, when the backend told us, its type. */
+interface QueryResultColumn {
+  name: string;
+  /** Native type as the backend spells it (`VARCHAR`, `DateTime64(3)`…). */
+  type?: string;
+}
+/** Sort state: which column, which way. */
+interface QueryResultSort {
+  column: string;
+  direction: "asc" | "desc";
+}
+/** Localized labels for the query results table component. */
+interface QueryResultsTableLabels {
+  emptyMessage?: string;
+  loadingMessage?: string;
+  rowsSuffix?: string;
+  rowNumber?: string;
+  sortAscending?: (column: string) => string;
+  sortDescending?: (column: string) => string;
+  clearSort?: (column: string) => string;
+  resizeColumn?: (column: string) => string;
+  openRow?: (index: number) => string;
+  rowDetailsTitle?: (index: number) => string;
+  nullValue?: string;
+  trueValue?: string;
+  falseValue?: string;
+}
+/** Props for the query results table component. */
+interface QueryResultsTableProps {
+  /** Column names, or columns with their types for a typed header. */
+  columns: Array<string | QueryResultColumn>;
+  rows: Array<Record<string, unknown>>;
+  /** Scroll height in px. `"fill"` takes whatever the parent gives. */
+  maxHeight?: number | "fill";
+  emptyMessage?: string;
+  loading?: boolean;
+  error?: string;
+  /** Click a header to sort. On by default; the sort is local to the table. */
+  sortable?: boolean;
+  /** Controlled sort. Omit to let the table keep its own. */
+  sort?: QueryResultSort | null;
+  onSortChange?: (sort: QueryResultSort | null) => void;
+  /** Row height in px. Every row is this tall — it is what makes 10,000 rows scroll. */
+  rowHeight?: number;
+  /** Open a row in a detail panel. On by default. */
+  rowDetails?: boolean;
+  /** Extra content in the footer, after the row count — elapsed time, bytes read. */
+  footer?: ReactNode;
+  labels?: QueryResultsTableLabels;
+  className?: string;
+}
+/** Render a cell value the way a query tool should: nothing is silently blank. */
+declare function formatQueryCell(value: unknown, labels: Pick<Required<QueryResultsTableLabels>, "nullValue" | "trueValue" | "falseValue">): {
+  text: string;
+  isNull: boolean;
+};
+/**
+ * QueryResultsTable — the answer, in the shape the database gave it.
+ *
+ * A result set is the one table the reader has not seen before, so the
+ * header carries the type of each column and the cells never lie by omission:
+ * `NULL` is written out, booleans are words, objects are their JSON. Sorting is
+ * local because the rows are already here — a second round trip for an ORDER
+ * BY the reader could have typed is a poor trade. Rows are windowed, so the
+ * 10,000-row cap a backend applies is a scroll, not a stall.
+ *
+ * @example
+ * ```tsx
+ * <QueryResultsTable
+ *   columns={result.columns}
+ *   rows={result.rows}
+ *   maxHeight="fill"
+ *   footer={<span>{result.elapsed} ms</span>}
+ * />
+ * ```
+ */
+declare function QueryResultsTable({ columns: rawColumns, rows, maxHeight, emptyMessage, loading, error, sortable, sort: controlledSort, onSortChange, rowHeight, rowDetails, footer, labels: customLabels, className }: QueryResultsTableProps): import("react").JSX.Element;
+declare namespace QueryResultsTable {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/schema-tree.d.ts
+/** One column of a queryable table. */
+interface SchemaTreeColumn {
+  name: string;
+  /** Native type as the backend spells it. Resolved to a glyph for display. */
+  type?: string;
+  /** One line about what the column holds, for a hover. */
+  description?: string;
+}
+/** One table (or view) the reader can query. */
+interface SchemaTreeTable {
+  name: string;
+  columns: SchemaTreeColumn[];
+  /** A word after the name — "view", "rollup" — for tables that are not plain tables. */
+  kind?: string;
+  description?: string;
+}
+/** Localized strings for the schema tree. */
+interface SchemaTreeLabels {
+  heading?: string;
+  searchPlaceholder?: string;
+  searchLabel?: string;
+  empty?: string;
+  loading?: string;
+  insert?: (name: string) => string;
+  preview?: (table: string) => string;
+  toggle?: (table: string) => string;
+  columnCount?: (count: number) => string;
+}
+/** Props for the schema tree component. */
+interface SchemaTreeProps {
+  tables: SchemaTreeTable[];
+  loading?: boolean;
+  /** Tables open by default. Omit to open the first. */
+  defaultExpanded?: string[];
+  /** Put a table or column name into the editor at the cursor. */
+  onInsert?: (name: string, kind: "table" | "column", table: string) => void;
+  /** Run a `SELECT * … LIMIT n` on the table. The caller writes the SQL. */
+  onPreview?: (table: string) => void;
+  header?: ReactNode;
+  className?: string;
+  labels?: SchemaTreeLabels;
+}
+/**
+ * SchemaTree — what can be queried, and what it is called.
+ *
+ * A SQL editor without a schema beside it is an exam: the reader must already
+ * know that the column is `created_at` and not `timestamp`. The tree answers
+ * that at a glance, and its two actions are the two things people do with the
+ * answer — put the name in the query, or look at the rows to see what the
+ * name means.
+ *
+ * Search matches tables *and* columns, because "where is `utm_source`" is
+ * asked more often than "what is in `sessions`".
+ *
+ * @example
+ * ```tsx
+ * <SchemaTree
+ *   tables={schema.tables}
+ *   onInsert={(name) => editor.current?.insertText(name)}
+ *   onPreview={(table) => run(`SELECT * FROM ${table} LIMIT 100`)}
+ * />
+ * ```
+ */
+declare function SchemaTree({ tables, loading, defaultExpanded, onInsert, onPreview, header, className, labels: customLabels }: SchemaTreeProps): import("react").JSX.Element;
+declare namespace SchemaTree {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/query-toolbar.d.ts
+/**
+ * What the run button says about the query it would run.
+ *
+ * - `idle` — nothing to say.
+ * - `changed` — the text differs from what last ran; the button is the way to see the new answer.
+ * - `current` — the text is what last ran; running again only refreshes.
+ */
+type QueryRunState = "idle" | "changed" | "current";
+/** Localized strings for the query toolbar. */
+interface QueryToolbarLabels {
+  run?: string;
+  cancel?: string;
+  runStatement?: string;
+  runSelection?: string;
+  runAll?: string;
+  runMenu?: string;
+  save?: string;
+  changedHint?: string;
+  currentHint?: string;
+  runningHint?: string;
+}
+/** Props for the query toolbar. */
+interface QueryToolbarProps {
+  onRun: () => void;
+  /** Present while running, the button turns into Cancel. */
+  onCancel?: () => void;
+  running?: boolean;
+  runState?: QueryRunState;
+  /** Why the run button is disabled, shown as its tooltip. */
+  runDisabledReason?: string;
+  /** Alternative runs offered under the split button. */
+  onRunSelection?: () => void;
+  /** True when there is a selection to run; the item is disabled otherwise. */
+  hasSelection?: boolean;
+  onRunAll?: () => void;
+  /** True when the editor holds more than one statement; Run All is hidden otherwise. */
+  multiStatement?: boolean;
+  onSave?: () => void;
+  saveDisabled?: boolean;
+  /** Controls after the run group — filters, variables, a connection picker. */
+  children?: ReactNode;
+  /** Controls at the far end — settings, share. */
+  trailing?: ReactNode;
+  /** The modifier-key glyph in the shortcut hint. `⌘` on macOS, `Ctrl` elsewhere. */
+  modifierKey?: string;
+  className?: string;
+  labels?: QueryToolbarLabels;
+}
+/**
+ * QueryToolbar — one button that always means "give me the answer".
+ *
+ * The run button carries state so the reader does not have to remember it:
+ * a changed query shows as the accent colour, an unchanged one as neutral, and
+ * a running one becomes Cancel. The alternatives (run selection, run the
+ * statement at the cursor, run all) sit behind a split so the primary action
+ * stays a single unambiguous target, which is what a keyboard shortcut is
+ * bound to.
+ *
+ * @example
+ * ```tsx
+ * <QueryToolbar
+ *   onRun={runAtCursor}
+ *   onCancel={cancel}
+ *   running={isRunning}
+ *   runState={sql === lastRun ? "current" : "changed"}
+ *   onSave={openSaveDialog}
+ * >
+ *   <QueryFiltersMenu … />
+ * </QueryToolbar>
+ * ```
+ */
+declare function QueryToolbar({ onRun, onCancel, running, runState, runDisabledReason, onRunSelection, hasSelection, onRunAll, multiStatement, onSave, saveDisabled, children, trailing, modifierKey, className, labels: customLabels }: QueryToolbarProps): import("react").JSX.Element;
+declare namespace QueryToolbar {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/query-output-pane.d.ts
+/** Which output the reader is looking at. */
+type QueryOutputView = "results" | "chart" | "split";
+/** What the last run cost, for the status bar. */
+interface QueryRunStats {
+  rowCount?: number;
+  /** Milliseconds. */
+  elapsed?: number;
+  bytesRead?: number;
+  rowsRead?: number;
+  /** True when the backend cut the result at its cap. */
+  truncated?: boolean;
+}
+/** Localized strings for the output pane. */
+interface QueryOutputPaneLabels {
+  results?: string;
+  chart?: string;
+  split?: string;
+  viewLabel?: string;
+  emptyTitle?: string;
+  emptyDescription?: string;
+  emptyHint?: ReactNode;
+  loadingTitle?: string;
+  loadingDescription?: (seconds: number) => string;
+  errorTitle?: string;
+  cancelled?: string;
+  cancel?: string;
+  rows?: (count: number) => string;
+  elapsed?: (ms: number) => string;
+  bytesRead?: (bytes: number) => string;
+  rowsRead?: (count: number) => string;
+  truncated?: string;
+  dismissError?: string;
+}
+/** Props for the output pane. */
+interface QueryOutputPaneProps {
+  view: QueryOutputView;
+  onViewChange: (view: QueryOutputView) => void;
+  /** The results table. */
+  results: ReactNode;
+  /** The chart builder. Omit to hide the chart view entirely. */
+  chart?: ReactNode;
+  /** Run lifecycle. `idle` is before the first run. */
+  status: "idle" | "running" | "success" | "error" | "cancelled";
+  /** Backend error text for `status="error"`. */
+  error?: string;
+  /** Seconds the current run has been going, for the loading state. */
+  runningSeconds?: number;
+  onCancel?: () => void;
+  stats?: QueryRunStats;
+  /** Controls at the right of the view switch — export, chart settings. */
+  actions?: ReactNode;
+  /** Extra status-bar content. */
+  statusExtra?: ReactNode;
+  /** A notice above the output — a warning about a placeholder, a sample note. */
+  banner?: ReactNode;
+  /** Retry from the error state. */
+  onRetry?: () => void;
+  className?: string;
+  labels?: QueryOutputPaneLabels;
+}
+/**
+ * QueryOutputPane — where the answer lands, and what it cost.
+ *
+ * The pane owns the run lifecycle's *presentation*: nothing yet, running (with
+ * a clock and a way out), failed (with the backend's words, not a paraphrase),
+ * and done. Done is a table, a chart, or both side by side — the split is a
+ * real resizable pair, because comparing a number to its bar is the point of
+ * showing both. The status bar keeps the cost visible: rows, time, bytes
+ * scanned, and whether the backend truncated the result, so a reader never
+ * mistakes a capped answer for a complete one.
+ *
+ * @example
+ * ```tsx
+ * <QueryOutputPane
+ *   view={view} onViewChange={setView}
+ *   status={status} error={error} stats={stats}
+ *   results={<QueryResultsTable … maxHeight="fill" />}
+ *   chart={<QueryResultChart … />}
+ * />
+ * ```
+ */
+declare function QueryOutputPane({ view, onViewChange, results, chart, status, error, runningSeconds, onCancel, stats, actions, statusExtra, banner, onRetry, className, labels: customLabels }: QueryOutputPaneProps): import("react").JSX.Element;
+declare namespace QueryOutputPane {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/query-result-chart.d.ts
+/** How the result is drawn. */
+type QueryChartType = "line" | "bar" | "area" | "pie" | "number";
+/** The reader's choices — held by the caller so a saved query can keep them. */
+interface QueryChartConfig {
+  type: QueryChartType;
+  /** The category / time column. Unused for `number`. */
+  xColumn?: string;
+  /** The value columns. `pie` and `number` use the first. */
+  yColumns: string[];
+  stacked?: boolean;
+}
+/** Localized strings for the chart builder. */
+interface QueryResultChartLabels {
+  typeLabel?: string;
+  line?: string;
+  bar?: string;
+  area?: string;
+  pie?: string;
+  number?: string;
+  xAxis?: string;
+  yAxis?: string;
+  stacked?: string;
+  noNumeric?: string;
+  noNumericDescription?: string;
+  pickSeries?: string;
+  pickSeriesDescription?: string;
+  chartLabel?: string;
+}
+/** Props for the chart builder. */
+interface QueryResultChartProps {
+  columns: QueryResultColumn[];
+  rows: Array<Record<string, unknown>>;
+  config: QueryChartConfig;
+  onConfigChange: (config: QueryChartConfig) => void;
+  /** Hide the controls, for an embedded read-only card. */
+  showControls?: boolean;
+  /** Chart height in px. Defaults to filling the parent. */
+  height?: number;
+  /** Rows beyond this are dropped from the chart, not the table. */
+  maxPoints?: number;
+  className?: string;
+  labels?: QueryResultChartLabels;
+}
+/**
+ * Which columns can be values. The declared type decides when the backend
+ * gave one; a sample of the rows decides otherwise, so a `count()` that came
+ * back as a string still charts.
+ */
+declare function numericResultColumns(columns: QueryResultColumn[], rows: Array<Record<string, unknown>>): QueryResultColumn[];
+/** A starting configuration for a fresh result: first non-numeric column as x, the numerics as y. */
+declare function defaultQueryChartConfig(columns: QueryResultColumn[], rows: Array<Record<string, unknown>>): QueryChartConfig;
+/**
+ * QueryResultChart — the same rows, as a picture.
+ *
+ * A result set is not a chart until someone says which column is the axis and
+ * which are the values. This makes that a two-control decision with sensible
+ * defaults: the first text or date column is the axis, the numeric columns are
+ * the values, and a single-row single-number answer is just the number, large.
+ * The configuration is the caller's, so it can be saved alongside the SQL.
+ *
+ * @example
+ * ```tsx
+ * const [config, setConfig] = useState(() => defaultQueryChartConfig(columns, rows));
+ * <QueryResultChart columns={columns} rows={rows} config={config} onConfigChange={setConfig} />
+ * ```
+ */
+declare function QueryResultChart({ columns, rows, config, onConfigChange, showControls, height, maxPoints, className, labels: customLabels }: QueryResultChartProps): import("react").JSX.Element;
+declare namespace QueryResultChart {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/query-filters-menu.d.ts
+/** How a property is compared. The set OpenPanel and PostHog both converge on. */
+type QueryFilterOperator = "is" | "isNot" | "contains" | "notContains" | "startsWith" | "endsWith" | "regex" | "gt" | "gte" | "lt" | "lte" | "isNull" | "isNotNull";
+/** One property condition. */
+interface QueryPropertyFilter {
+  id: string;
+  field: string;
+  operator: QueryFilterOperator;
+  value: string;
+}
+/** The filters a query can carry, applied where the SQL puts `{filters}`. */
+interface QueryFilters {
+  dateRange: DateRange | null;
+  properties: QueryPropertyFilter[];
+}
+/** A column the filters can name. */
+interface QueryFilterField {
+  name: string;
+  type?: string;
+}
+/** Localized strings for the filters menu. */
+interface QueryFiltersMenuLabels {
+  trigger?: string;
+  title?: string;
+  dateRange?: string;
+  dateRangePlaceholder?: string;
+  properties?: string;
+  addProperty?: string;
+  removeProperty?: (field: string) => string;
+  field?: string;
+  operator?: string;
+  value?: string;
+  reset?: string;
+  insertPlaceholder?: string;
+  missingPlaceholderTitle?: string;
+  missingPlaceholder?: string;
+  placeholderHint?: string;
+  valuesLoading?: string;
+  noValues?: string;
+  operators?: Partial<Record<QueryFilterOperator, string>>;
+  activeCount?: (count: number) => string;
+}
+/** Operators without a value. */
+declare const VALUELESS_OPERATORS: ReadonlySet<QueryFilterOperator>;
+/** Props for the filters menu. */
+interface QueryFiltersMenuProps {
+  value: QueryFilters;
+  onChange: (filters: QueryFilters) => void;
+  /** Columns offered in the field picker. */
+  fields: QueryFilterField[];
+  /** Whether the SQL contains `{filters}`. Drives the warning and the insert button. */
+  placeholderPresent?: boolean;
+  onInsertPlaceholder?: () => void;
+  /**
+   * Known values for a field, offered as suggestions in the value box. Called
+   * once per field while the menu is open; typing still accepts anything.
+   */
+  onLoadValues?: (field: string) => Promise<string[]>;
+  presets?: DateRangePreset[];
+  disabled?: boolean;
+  className?: string;
+  labels?: QueryFiltersMenuLabels;
+}
+/** True when any filter would change the query. */
+declare function hasActiveQueryFilters(filters: QueryFilters): boolean;
+/** How many filters are set, for the badge. */
+declare function countActiveQueryFilters(filters: QueryFilters): number;
+/** An empty filter set. */
+declare const EMPTY_QUERY_FILTERS: QueryFilters;
+/**
+ * QueryFiltersMenu — conditions the reader would rather not type.
+ *
+ * A time range and a few equality filters are the WHERE clause most queries
+ * share, and retyping them for every query is how a dashboard's filters end
+ * up disagreeing with its queries. This holds them as data and hands them to
+ * the SQL through a `{filters}` placeholder, the way PostHog does — the query
+ * says *where* they apply, the menu says *what* they are. When the placeholder
+ * is missing the menu says so, loudly, because silently unapplied filters are
+ * the worst kind.
+ *
+ * @example
+ * ```tsx
+ * <QueryFiltersMenu
+ *   value={filters} onChange={setFilters}
+ *   fields={schema.columns}
+ *   placeholderPresent={sqlUsesPlaceholder(sql, "filters")}
+ *   onInsertPlaceholder={() => editor.current?.insertText("{filters}")}
+ * />
+ * ```
+ */
+declare function QueryFiltersMenu({ value, onChange, fields, placeholderPresent, onInsertPlaceholder, onLoadValues, presets, disabled, className, labels: customLabels }: QueryFiltersMenuProps): import("react").JSX.Element;
+declare namespace QueryFiltersMenu {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/query-variables-menu.d.ts
+/** A named value the query reads as `{variables.name}`. */
+interface QueryVariable {
+  id: string;
+  name: string;
+  value: string;
+}
+/** Localized strings for the variables menu. */
+interface QueryVariablesMenuLabels {
+  trigger?: string;
+  title?: string;
+  hint?: string;
+  name?: string;
+  value?: string;
+  add?: string;
+  remove?: (name: string) => string;
+  insert?: (name: string) => string;
+  empty?: string;
+  invalidName?: string;
+  activeCount?: (count: number) => string;
+}
+/** Props for the variables menu. */
+interface QueryVariablesMenuProps {
+  value: QueryVariable[];
+  onChange: (variables: QueryVariable[]) => void;
+  /** Put `{variables.name}` into the editor at the cursor. */
+  onInsert?: (name: string) => void;
+  disabled?: boolean;
+  /** Why the menu is disabled, shown as the trigger's tooltip. */
+  disabledReason?: string;
+  className?: string;
+  labels?: QueryVariablesMenuLabels;
+}
+/** True when the name can be referenced from SQL. */
+declare function isValidQueryVariableName(name: string): boolean;
+/**
+ * QueryVariablesMenu — the parts of a query that change between runs.
+ *
+ * A saved query with a literal `'2026-09-01'` in it is a query that lies a
+ * week later. Variables move that value out of the text and into a small
+ * form, so the same SQL answers the same question for a different week — or
+ * a different plan, or a different country — without an edit. The menu owns
+ * only the names and values; substitution is the caller's, because how a
+ * value is quoted is the dialect's business.
+ *
+ * @example
+ * ```tsx
+ * <QueryVariablesMenu
+ *   value={variables} onChange={setVariables}
+ *   onInsert={(name) => editor.current?.insertText(`{variables.${name}}`)}
+ * />
+ * ```
+ */
+declare function QueryVariablesMenu({ value, onChange, onInsert, disabled, disabledReason, className, labels: customLabels }: QueryVariablesMenuProps): import("react").JSX.Element;
+declare namespace QueryVariablesMenu {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/query-history-list.d.ts
+/** One past run. */
+interface QueryHistoryItem {
+  id: string;
+  query: string;
+  /** ISO timestamp. */
+  ranAt: string;
+  status: "success" | "error";
+  rowCount?: number;
+  /** Milliseconds. */
+  elapsed?: number;
+  error?: string;
+}
+/** Localized strings for the history list. */
+interface QueryHistoryListLabels {
+  heading?: string;
+  empty?: string;
+  loading?: string;
+  clear?: string;
+  rerun?: (query: string) => string;
+  load?: (query: string) => string;
+  rows?: (count: number) => string;
+  elapsed?: (ms: number) => string;
+  failed?: string;
+  succeeded?: string;
+  ranAt?: (iso: string) => string;
+}
+/** Props for the history list. */
+interface QueryHistoryListProps {
+  items: QueryHistoryItem[];
+  loading?: boolean;
+  /** Put the query back in the editor. */
+  onLoad?: (item: QueryHistoryItem) => void;
+  /** Run it again as it was. */
+  onRerun?: (item: QueryHistoryItem) => void;
+  onClear?: () => void;
+  header?: ReactNode;
+  className?: string;
+  labels?: QueryHistoryListLabels;
+}
+/**
+ * QueryHistoryList — what was asked, and whether it answered.
+ *
+ * Half of query writing is recovering the query from twenty minutes ago that
+ * almost worked. The list keeps each run with its outcome, so a failed
+ * attempt is as easy to get back as a good one, and the cost of a run is
+ * visible before it is repeated.
+ *
+ * @example
+ * ```tsx
+ * <QueryHistoryList items={history} onLoad={(item) => setSql(item.query)} onRerun={(item) => run(item.query)} />
+ * ```
+ */
+declare function QueryHistoryList({ items, loading, onLoad, onRerun, onClear, header, className, labels: customLabels }: QueryHistoryListProps): import("react").JSX.Element;
+declare namespace QueryHistoryList {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/save-query-dialog.d.ts
+/** What the dialog collects. */
+interface SaveQueryValues {
+  name: string;
+  description: string;
+  isPublic: boolean;
+  /** The SQL chosen from the candidates. */
+  sql: string;
+}
+/** Localized strings for the save dialog. */
+interface SaveQueryDialogLabels {
+  createTitle?: string;
+  updateTitle?: string;
+  description?: string;
+  name?: string;
+  namePlaceholder?: string;
+  descriptionField?: string;
+  descriptionPlaceholder?: string;
+  isPublic?: string;
+  isPublicHint?: string;
+  save?: string;
+  cancel?: string;
+  nameRequired?: string;
+  candidate?: (index: number, total: number) => string;
+  selection?: string;
+  previous?: string;
+  next?: string;
+}
+/** Props for the save dialog. */
+interface SaveQueryDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onSubmit: (values: SaveQueryValues) => void | Promise<void>;
+  /** The SQL to save. Several when the editor holds several statements. */
+  candidates: string[];
+  /** Which candidate to start on. */
+  initialCandidate?: number;
+  /** True when the single candidate is the editor selection rather than a statement. */
+  candidateIsSelection?: boolean;
+  /** Present when editing an existing saved query. */
+  initialValues?: Partial<Omit<SaveQueryValues, "sql">>;
+  mode?: "create" | "update";
+  saving?: boolean;
+  error?: string;
+  labels?: SaveQueryDialogLabels;
+}
+/**
+ * SaveQueryDialog — give the query a name it can be found by.
+ *
+ * Saving is the moment a query stops being scratch work, so the dialog asks
+ * for the things a colleague will need: a name, a line about what it answers,
+ * and whether they may see it. When the editor holds several statements the
+ * dialog pages through them rather than guessing, because the one at the
+ * cursor is usually — not always — the one meant.
+ *
+ * @example
+ * ```tsx
+ * <SaveQueryDialog
+ *   open={saving} onOpenChange={setSaving}
+ *   candidates={statements.map((s) => s.text)}
+ *   initialCandidate={currentIndex}
+ *   onSubmit={(values) => saveMutation.mutate(values)}
+ * />
+ * ```
+ */
+declare function SaveQueryDialog({ open, onOpenChange, onSubmit, candidates, initialCandidate, candidateIsSelection, initialValues, mode, saving, error, labels: customLabels }: SaveQueryDialogProps): import("react").JSX.Element;
+declare namespace SaveQueryDialog {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/query-workspace.d.ts
+/** Localized strings for the workspace layout. */
+interface QueryWorkspaceLabels {
+  sidebar?: string;
+  openSidebar?: string;
+  closeSidebar?: string;
+  editor?: string;
+  output?: string;
+}
+/** Props for the workspace layout. */
+interface QueryWorkspaceProps {
+  /** Schema tree, saved queries, history — whatever helps write the query. */
+  sidebar?: ReactNode;
+  sidebarOpen?: boolean;
+  onSidebarOpenChange?: (open: boolean) => void;
+  /** Tabs, or a page header, above the toolbar. */
+  header?: ReactNode;
+  toolbar?: ReactNode;
+  editor: ReactNode;
+  output: ReactNode;
+  /** Stable id under which panel sizes are remembered in `localStorage`. */
+  storageKey?: string;
+  /** Sidebar width as a percentage of the workspace. */
+  defaultSidebarSize?: number;
+  /** Editor height as a percentage of the column. */
+  defaultEditorSize?: number;
+  className?: string;
+  labels?: QueryWorkspaceLabels;
+}
+/**
+ * QueryWorkspace — three panes, one job.
+ *
+ * The shape every SQL tool converges on: what can be queried on the left,
+ * the query on top, the answer below. The panes resize and the sidebar
+ * collapses, and both are remembered per `storageKey`, because the layout a
+ * reader settles into is part of their tool. The workspace is only a frame —
+ * the toolbar, editor and output are slots, so the same frame serves a full
+ * page and an embedded card.
+ *
+ * @example
+ * ```tsx
+ * <QueryWorkspace
+ *   storageKey="project-query"
+ *   sidebar={<SchemaTree … />}
+ *   toolbar={<QueryToolbar … />}
+ *   editor={<SqlEditor height="fill" … />}
+ *   output={<QueryOutputPane … />}
+ * />
+ * ```
+ */
+declare function QueryWorkspace({ sidebar, sidebarOpen: controlledSidebarOpen, onSidebarOpenChange, header, toolbar, editor, output, storageKey, defaultSidebarSize, defaultEditorSize, className, labels: customLabels }: QueryWorkspaceProps): import("react").JSX.Element;
+declare namespace QueryWorkspace {
+  var displayName: string;
+}
+//#endregion
+//#region src/shells/sql-editor.d.ts
+/** CodeMirror 확장. `@codemirror/state`의 `Extension`. */
+type SqlEditorExtension = import("@codemirror/state").Extension;
+/** CodeMirror 키 바인딩. `@codemirror/view`의 `KeyBinding`. */
+type SqlEditorKeyBinding = import("@codemirror/view").KeyBinding;
+/**
+ * 자동완성 스키마. `@codemirror/lang-sql`의 `SQLNamespace` —
+ * `{ table: ["col", ...] }` 형태로 테이블/컬럼을 알려준다.
+ */
+type SqlEditorSchema = import("@codemirror/lang-sql").SQLNamespace;
+/** 추가 자동완성 소스. `@codemirror/autocomplete`의 `CompletionSource`. */
+type SqlEditorCompletionSource = import("@codemirror/autocomplete").CompletionSource;
+/** 실행 시점의 편집기 상태. 선택 영역만 실행하거나 커서 위치의 문장을 고를 때 쓴다. */
+interface SqlEditorRunContext {
+  /** 선택된 텍스트. 선택이 없으면 `null`. */
+  selection: string | null;
+  /** 커서(선택의 head) 오프셋. */
+  cursorOffset: number;
+}
+/** 편집기를 바깥에서 조작하는 핸들. 스키마 트리의 "커서에 삽입"이 대표적인 용도. */
+interface SqlEditorHandle {
+  focus: () => void;
+  /** 커서 위치에 텍스트를 넣고, 선택이 있으면 그 자리를 대체한다. */
+  insertText: (text: string) => void;
+  /** 현재 선택 텍스트. 선택이 없으면 `null`. */
+  getSelection: () => string | null;
+  getCursorOffset: () => number;
+}
+/** 편집기 색상. `auto`는 OptThemeProvider의 resolved mode를 따른다. */
+type SqlEditorTheme = "light" | "dark" | "auto";
+/** Localized labels for the sql editor component. */
+interface SqlEditorLabels {
+  placeholder?: string;
+  runHint?: string;
+  runButton?: string;
+  editor?: string;
+}
+/** Props for the sql editor component. */
+interface SqlEditorProps {
+  value: string;
+  onChange: (sql: string) => void;
+  /** Mod+Enter. 두 번째 인자로 선택 영역과 커서 위치를 받는다. */
+  onRun?: (sql: string, context: SqlEditorRunContext) => void;
+  /** Shift+Enter — 실행 후 다음 셀/탭으로 넘어가는 노트북형 흐름. */
+  onRunAndAdvance?: (sql: string, context: SqlEditorRunContext) => void;
+  placeholder?: string;
+  readOnly?: boolean;
+  /** px 고정 높이. `"fill"`이면 부모가 정한 높이를 채운다. */
+  height?: number | "fill";
+  /**
+   * 테이블/컬럼 자동완성 스키마. 값이 바뀌면 에디터를 다시 만들지 않고
+   * 자동완성만 재구성하므로, 카탈로그가 자주 갱신되는 화면에서도 커서와
+   * 실행 취소 이력이 유지된다.
+   */
+  schema?: SqlEditorSchema;
+  /** 스키마 자동완성에 더해 붙일 완성 소스 (함수 시그니처, 스니펫 등). */
+  completionSources?: SqlEditorCompletionSource[];
+  /** 추가 키 바인딩. 내장 실행 바인딩보다 먼저 평가된다. */
+  keymap?: SqlEditorKeyBinding[];
+  /** 임의의 CodeMirror 확장. 내장 확장 뒤에 붙어 우선권을 갖는다. */
+  extensions?: SqlEditorExtension[];
+  /** 편집 영역의 접근성 레이블. */
+  ariaLabel?: string;
+  autoFocus?: boolean;
+  /**
+   * 실행 힌트와 Run 버튼 표시 여부. 기본값은 `onRun`이 있을 때 표시.
+   * 자체 툴바를 쓰는 화면에서 `false`로 끈다.
+   */
+  showFooter?: boolean;
+  /** 줄 번호 거터. 기본 표시. */
+  lineNumbers?: boolean;
+  /** 편집기 색상. 기본 `auto`. */
+  theme?: SqlEditorTheme;
+  labels?: SqlEditorLabels;
+  className?: string;
+}
+/**
+ * SqlEditor — a query is text until it runs; this is where it is text.
+ *
+ * Built on CodeMirror, loaded on first mount so pages that never open the
+ * editor never pay for it. The editor is created once: schema, theme and
+ * read-only changes are applied through compartments, so a catalogue refresh
+ * or a theme switch does not throw away the cursor and the undo history.
+ *
+ * @example
+ * ```tsx
+ * const editor = useRef<SqlEditorHandle>(null);
+ * <SqlEditor
+ *   ref={editor}
+ *   value={sql}
+ *   onChange={setSql}
+ *   onRun={(text, { selection }) => run(selection ?? text)}
+ *   schema={{ events: ["id", "name", "created_at"] }}
+ *   height="fill"
+ * />
+ * ```
+ */
+declare const SqlEditor: React.ForwardRefExoticComponent<SqlEditorProps & React.RefAttributes<SqlEditorHandle>>;
+//#endregion
 //#region src/shells/event-timeline.d.ts
 /** Semantic colour of a timeline node. */
 type EventTimelineTone = "default" | "accent" | "success" | "warning" | "danger";
@@ -1324,4 +2146,4 @@ declare namespace FieldSidebar {
   var displayName: string;
 }
 //#endregion
-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 };
+export { EventTimelineItem as $, EditorToolbarProps as $n, QueryToolbar as $t, QueryCellAction as A, ToastVariant as An, QueryFilterField as At, removeClause as B, EnvPanel as Bn, QueryChartConfig as Bt, TimeRangePreset as C, FailureListProps as Cn, QueryHistoryListProps as Ct, QueryField as D, ToastMessage as Dn, QueryVariablesMenuProps as Dt, QueryBarProps as E, ToastContextValue as En, QueryVariablesMenuLabels as Et, addClause as F, DataTableProps as Fn, QueryFiltersMenuProps as Ft, FlyoutProps as G, DeploymentTimelineProps as Gn, defaultQueryChartConfig as Gt, withoutField as H, ProjectSwitcher as Hn, QueryResultChart as Ht, applyCellAction as I, DomainTable as In, QueryPropertyFilter as It, ScoreBreakdown as J, FaqAccordion as Jn, QueryOutputPaneLabels as Jt, ScoreAxis as K, SettingsForm as Kn, numericResultColumns as Kt, fieldValues as L, DomainTableProps as Ln, VALUELESS_OPERATORS as Lt, QueryFieldClause as M, useToast as Mn, QueryFilters as Mt, QueryOperator as N, ColumnDef as Nn, QueryFiltersMenu as Nt, EMPTY_QUERY as O, ToastProvider as On, isValidQueryVariableName as Ot, QueryTermClause as P, DataTable as Pn, QueryFiltersMenuLabels as Pt, EventTimelineGroup as Q, EditorToolbar as Qn, QueryRunState as Qt, isEmptyQuery as R, BranchSelect as Rn, countActiveQueryFilters as Rt, TimeRangeControlProps as S, FailureListLabels as Sn, QueryHistoryListLabels as St, QueryBarLabels as T, ToastAction as Tn, QueryVariablesMenu as Tt, Flyout as U, ProjectSwitcherProps as Un, QueryResultChartLabels as Ut, withFieldValue as V, EnvPanelProps as Vn, QueryChartType as Vt, FlyoutLabels as W, DeploymentTimeline as Wn, QueryResultChartProps as Wt, ScoreBreakdownProps as X, ContentTabs as Xn, QueryOutputView as Xt, ScoreBreakdownLabels as Y, FaqAccordionProps as Yn, QueryOutputPaneProps as Yt, EventTimeline as Z, ContentTabsProps as Zn, QueryRunStats as Zt, TimeSeriesPanelProps as _, KeyValueEditor as _n, SaveQueryDialogLabels as _t, FieldValueCount as a, SchemaTreeProps as an, StatusSelectProps as ar, SqlEditorExtension as at, TimeRangeControl as b, KeyValueEntry as bn, QueryHistoryItem as bt, LogColumnPriority as c, QueryResultSort as cn, DashboardGrid as cr, SqlEditorLabels as ct, LogTable as d, QueryResultsTableProps as dn, CommandPaletteTriggerProps as dr, SqlEditorSchema as dt, QueryToolbarLabels as en, SidebarNav as er, EventTimelineLabels as et, LogTableHandle as f, formatQueryCell as fn, CommandPalette as fr, SqlEditorTheme as ft, TimeSeriesPanelLabels as g, WorkflowCanvasStep as gn, SaveQueryDialog as gt, TimeSeriesPanel as h, WorkflowCanvasProps as hn, QueryWorkspaceProps as ht, FieldSummary as i, SchemaTreeLabels as in, StatusSelect as ir, SqlEditorCompletionSource as it, QueryClause as j, toast as jn, QueryFilterOperator as jt, Query as k, ToastProviderProps as kn, EMPTY_QUERY_FILTERS as kt, LogDensity as l, QueryResultsTable as ln, DashboardGridProps as lr, SqlEditorProps as lt, LogTableProps as m, WorkflowCanvasConnection as mn, QueryWorkspaceLabels as mt, FieldSidebarLabels as n, SchemaTree as nn, AppMenubar as nr, EventTimelineTone as nt, LogCellAction as o, SchemaTreeTable as on, SearchCombobox as or, SqlEditorHandle as ot, LogTableLabels as p, WorkflowCanvas as pn, CommandPaletteProps as pr, QueryWorkspace as pt, ScoreBand as q, SettingsFormProps as qn, QueryOutputPane as qt, FieldSidebarProps as r, SchemaTreeColumn as rn, AppMenubarProps as rr, SqlEditor as rt, LogColumn as s, QueryResultColumn as sn, SearchComboboxProps as sr, SqlEditorKeyBinding as st, FieldSidebar as t, QueryToolbarProps as tn, SidebarNavProps as tr, EventTimelineProps as tt, LogSort as u, QueryResultsTableLabels as un, CommandPaletteTrigger as ur, SqlEditorRunContext as ut, DEFAULT_TIME_PRESETS as v, KeyValueEditorLabels as vn, SaveQueryDialogProps as vt, QueryBar as w, NotificationToast as wn, QueryVariable as wt, TimeRangeControlLabels as x, FailureList as xn, QueryHistoryList as xt, RefreshSetting as y, KeyValueEditorProps as yn, SaveQueryValues as yt, queryFields as z, BranchSelectProps as zn, hasActiveQueryFilters as zt };