@pythia-software/query-table-core 0.9.9 → 1.0.0

package/dist/index.d.ts

@@ -89,7 +89,335 @@ type CellDisplay = JsonCellDisplay | ({
     lines?: number;
 };
 
+/** Filter operators. Every value can be NULL, so is_null/is_not_null are valid for every field type. */
+type FilterOp = "=" | "!=" | ">" | ">=" | "<" | "<=" | "contains" | "starts_with" | "ends_with" | "matches_regex" | "not_matches_regex" | "length_gt" | "length_lt" | "length_eq" | "includes" | "is_null" | "is_not_null";
+/** One predicate. `value` is the raw string the UI captured; executors coerce it by the field's declared type. Datetime comparisons also accept signed offsets such as "-1h" relative to `now`. `negated` is a null-exclusive NOT, set only for ops without a complement. */
+interface WireWhereClause {
+    field: string;
+    op: FilterOp;
+    value: string;
+    negated?: boolean;
+}
+/** One branch of an OR group that ANDs several literals. Branches do not nest. */
+interface WireWhereConjunction {
+    all: WireWhereClause[];
+}
+/** One alternative of an OR group: a literal or a conjunction. */
+type WireWhereBranch = WireWhereClause | WireWhereConjunction;
+/** A disjunction of literals or conjunctions: (a AND b) OR c. */
+interface WireOrGroup {
+    any: WireWhereBranch[];
+}
+/** One conjunct of a WHERE: a literal or an OR group. A WHERE is the AND of its terms; every literal counts against the 100-predicate budget. */
+type WireWhereTerm = WireWhereClause | WireOrGroup;
+/** Sort by the first capture group of a regex match (or the whole match); a non-match is NULL. */
+interface RegexExtract {
+    regex: string;
+}
+/** One ORDER BY term; array order is sort priority. */
+interface OrderByClause {
+    field: string;
+    dir: "asc" | "desc";
+    /** NULL placement; omitted is last. */
+    nulls?: "first" | "last";
+    extract?: RegexExtract;
+}
+/** A single aggregate operation; only count needs no measure field. */
+type AggOp = "count" | "count_distinct" | "sum" | "avg" | "min" | "max";
+type MetricScope = "allMatching" | "shownRows";
+/** Calendar grouping of the first group key. Calendar intervals key a bucket by its start instant; hourOfDay (0-23) and dayOfWeek (ISO 1-7) key a slot by number. Whole intervals and occurrences are planned by the client into plain calendar metrics and never cross the wire. */
+interface WireMetricDateGrouping {
+    field: string;
+    interval: "hour" | "day" | "week" | "month" | "year" | "hourOfDay" | "dayOfWeek";
+    /** IANA identifier; omitted is UTC. */
+    timeZone?: string;
+    /** Add a bucket for every interval of the range. */
+    includeEmpty: boolean;
+    range: "query" | "observed" | "custom";
+    start?: string;
+    end?: string;
+}
+/** The only display state on the wire: scatter pairs `expression` with `expressionY`. */
+interface MetricDisplayHint {
+    kind: "scatter";
+}
+interface WireMetricSort {
+    key: "value" | "y" | "count" | "samples" | `group${number}`;
+    dir: "asc" | "desc";
+    nulls?: "first" | "last";
+}
+/** A box or histogram over `input` per group instead of a scalar value. */
+interface MetricDistribution {
+    kind: "box" | "histogram";
+    input: string;
+    whiskers?: "minmax" | "tukey";
+    bins?: number;
+}
+interface MetricMinCountDistinct {
+    min: number;
+    distinct: string;
+}
+interface MetricMinCountSum {
+    min: number;
+    sum: string;
+}
+/** Drop small groups before sorting, groupLimit and Other: a number counts rows; an object counts a field's distinct non-null values or sums a numeric field. Removed groups are reported as hiddenGroups. */
+type MetricMinCount = number | MetricMinCountDistinct | MetricMinCountSum;
+/** One metric as sent: an AggregationClause without its presentation (label, layout, display other than scatter, window, share). */
+interface MetricSpecV3 {
+    dateGrouping?: WireMetricDateGrouping;
+    display?: MetricDisplayHint;
+    /** A formula over aggregates; replaces op/field. */
+    expression?: string;
+    /** The scatter y expression. */
+    expressionY?: string;
+    scope?: MetricScope;
+    sort?: WireMetricSort[];
+    groupLimit?: number;
+    distribution?: MetricDistribution;
+    /** Echoed by the result entry. */
+    id: string;
+    op: AggOp;
+    /** Measure field; omitted only for count. */
+    field?: string;
+    groupBy: string[];
+    /** The metric's own predicate, ANDed with the table WHERE. */
+    where?: WireWhereTerm[];
+    minCount?: MetricMinCount;
+}
+/** A grouping key that buckets a datetime field by calendar interval, keyed by the interval's start instant. Weeks start on Monday. */
+interface CalendarGroupKey {
+    field: string;
+    interval: "hour" | "day" | "week" | "month" | "year";
+    /** IANA identifier; omitted is UTC. */
+    timeZone?: string;
+}
+/** A field name (group by exact value) or a calendar key. */
+type GroupKey = string | CalendarGroupKey;
+/** One summary column of a grouping stage. Display and link columns are client-only. */
+interface WireSummaryColumn {
+    id: string;
+    op: "count" | "count_distinct" | "sum" | "avg" | "min" | "max" | "row" | "formula";
+    field?: string;
+    expression?: string;
+    label?: string;
+}
+/** The ordering that picks each group's representative row for ROW summaries. */
+interface WireRepresentativeRow {
+    orderBy: OrderByClause[];
+}
+/** One grouping stage over the complete source population; the result stage's where is HAVING. */
+interface WireGroupingDefinition {
+    keys: GroupKey[];
+    summaries: WireSummaryColumn[];
+    representative: WireRepresentativeRow | null;
+}
+/** Query state a host owns and registers with useQueryTable({ hostQuery }), such as a keyword clause it runs itself. It travels with the table query through saves, links, history and resets. params are named lists of strings, like URL search parameters, sorted by name; the host interprets them. Query Table passes it through uninterpreted. Version 0 marks a payload that could not be read and is always rejected on restore. */
+interface HostQueryState {
+    version: number;
+    params: Record<string, string[]>;
+}
+/** Distinct values of one server-filterable field: a literal, case-insensitive substring match on the value as text (empty matches all), ordered by count desc then value asc. textarray fields contribute each element. */
+interface DistinctRequestV3 {
+    field: string;
+    search: string;
+    limit: number;
+}
+/** The server's query handshake. */
+interface QueryCapabilitiesV3 {
+    regexSourceFilters?: boolean;
+    regexAggregateExpressions?: boolean;
+    /** Executes MetricSpec.where. */
+    metricFilters?: boolean;
+    /** Executes a numeric minCount and reports hiddenGroups. */
+    metricMinCount?: boolean;
+    /** Also executes an object minCount. */
+    metricMinCountMeasures?: boolean;
+    version: 3;
+    groupedRows: boolean;
+    calendarGrouping: boolean;
+    /** Executes the hourOfDay and dayOfWeek intervals. */
+    calendarCycles?: boolean;
+    /** Executes calendar grouping keys. */
+    calendarGroupKeys?: boolean;
+    computedSourceFilters: boolean;
+    regex: boolean;
+    maxRows: number;
+    maxGroups: number;
+    maxPopulation: number;
+    profile: string;
+}
+/** One v3 query: rows, metrics, groups or distinct values. source.where runs before grouping; result selects, filters (HAVING) and pages. */
+interface QueryRequestV3 {
+    version: 3;
+    profile: string;
+    /** Evaluation clock, epoch milliseconds. */
+    now: number;
+    /** Computed definition id to the revision the client planned with. */
+    expectedRevisions: Record<string, string>;
+    planToken?: string;
+    snapshot?: string;
+    source: ServerQuery;
+    result: ServerQuery;
+    grouping?: WireGroupingDefinition;
+    rows: boolean;
+    metrics: MetricSpecV3[];
+    /** Filter-value suggestions over source.where; requires rows false, no metrics and no grouping. */
+    distinct?: DistinctRequestV3;
+    /** Host-owned state, passed through uninterpreted: any JSON object. Query Table's TypeScript client sends a HostQueryState ({ version, params }); a host defines what its own clients send. */
+    hostState?: HostQueryState;
+}
+/** A metric value or group key: a number for count/sum/avg, the column's value for min/max; null when undefined. Go carries it as any, Swift as JSONValue. */
+type MetricValue = number | string | boolean | null;
+interface MetricBoxSummary {
+    n: number;
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    mean: number;
+    /** Lower whisker. */
+    low: number;
+    /** Upper whisker. */
+    high: number;
+    outliers: number[];
+    outlierCount: number;
+    whiskers: "minmax" | "tukey";
+    method: "exact-linear";
+}
+interface MetricBoxDistribution {
+    kind: "box";
+    /** null when the group has no numeric samples. */
+    summary: MetricBoxSummary | null;
+}
+/** Bin i is edges[i] <= value < edges[i+1]; the final bin includes its upper edge. */
+interface MetricHistogramDistribution {
+    kind: "histogram";
+    edges: number[];
+    counts: number[];
+    n: number;
+}
+type MetricDistributionResult = MetricBoxDistribution | MetricHistogramDistribution;
+/** One group of a metric result. `keys` has one entry per groupBy field ([] for a grand total); a null key is the NULL bucket. */
+interface MetricBucketV3 {
+    distribution?: MetricDistributionResult;
+    /** Distribution inputs that were NULL. */
+    nullCount?: number;
+    /** Distribution inputs that were errors. */
+    inputErrorCount?: number;
+    keys: MetricValue[];
+    /** The metric: a number for count/sum/avg, a column value for min/max, null when undefined. Swift reads an omitted value as null, as before. */
+    value: MetricValue;
+    /** COUNT(*) of rows in the group. */
+    count: number;
+    error?: string;
+    /** The scatter y value. */
+    y?: MetricValue;
+    yError?: string;
+}
+/** One metric's result, in request order. */
+interface MetricResultV3 {
+    id: string;
+    buckets: MetricBucketV3[];
+    scope?: MetricScope;
+    processedRows?: number;
+    /** Groups before groupLimit, excluding hidden groups. */
+    groupCount?: number;
+    coverage?: "exact" | "partial";
+    /** The metric could not be computed; siblings are unaffected. */
+    error?: string;
+    /** The machine-readable code of error; present with it. A newer server may send a code this client does not know. */
+    errorCode?: ErrorCode | (string & {});
+    /** Groups removed by minCount; present whenever it is set. */
+    hiddenGroups?: number;
+    /** The exact omitted additive quantity beyond groupLimit, when an executor computes it. */
+    other?: MetricBucketV3;
+}
 type FieldType = "text" | "number" | "enum" | "datetime" | "bool" | "textarray";
+/** What a canonical computed field may do in a view. Hints for client planning, never authorization. */
+interface ComputedFieldCapabilities {
+    /** Host-approved canonical predicates; omitted is closed. */
+    filter?: boolean;
+    type: FieldType;
+    select: boolean;
+    sort: boolean;
+    measure: boolean;
+    group: boolean;
+    reason?: string;
+}
+/** The execution envelope: profile, token, snapshot, resolved computed revisions and capabilities. A fingerprint is not authorization. */
+interface ComputedExecution {
+    profile: string;
+    /** Empty without a handshake. Swift reads an omitted token as empty, as before. */
+    planToken: string;
+    resolvedRevisions: Record<string, string>;
+    fields: Record<string, ComputedFieldCapabilities>;
+    fingerprint?: string;
+    snapshot?: string;
+}
+interface ProjectedFieldV3 {
+    name: string;
+    type: string;
+}
+/** The result's schema: grouped results use the group identity field. */
+interface ProjectedSchemaV3 {
+    name: string;
+    idField: string;
+    fields: ProjectedFieldV3[];
+}
+interface DistinctResultV3 {
+    /** Non-NULL matches as text, at most limit. */
+    values: string[];
+    hasMore: boolean;
+    /** The population has a NULL (textarray: NULL or empty), whatever the search. */
+    hasNull: boolean;
+}
+/** The answer to one QueryRequestV3. Row cells are JSON scalars, arrays (textarray) or {"computedError": code}. */
+interface QueryResultV3 {
+    sourceTotal: number;
+    version: 3;
+    now: number;
+    rows: (Record<string, unknown>)[];
+    total: number;
+    schema: ProjectedSchemaV3;
+    metrics: MetricResultV3[];
+    execution: ComputedExecution;
+    /** Present exactly when the request has distinct. */
+    distinct?: DistinctResultV3;
+}
+/** One stage (source or result) of a request. It has exactly these keys; view-only state never crosses the wire. */
+interface ServerQuery {
+    /** Field names to return. */
+    select: string[];
+    /** Pushdown predicates (CNF). */
+    where: WireWhereTerm[];
+    /** Server-sortable terms, remapped through FieldDef.sort.field. */
+    orderBy: OrderByClause[];
+    limit: number;
+    offset: number;
+}
+/** Every machine-readable error code the server or a client can produce. x-codes gives each code's HTTP status (null: never sent by a server), whether a retry can succeed (yes, no, or refresh: after refreshing the handshake or reloading) and its meaning; docs/errors.md is generated from it. Decoders must accept codes they do not know. */
+declare const ERROR_CODES: readonly ["invalid_json", "invalid_request", "method_not_allowed", "forbidden", "not_found", "request_too_large", "conflict", "quota_exceeded", "timeout", "cancelled", "unavailable", "internal", "version", "invalid_query", "profile_mismatch", "definition_changed", "execution_expired", "definition_unavailable", "definition_invalid", "datetime_value", "residual_query", "dataset", "schema", "source_required", "resolver_required", "resolver_scope", "snapshot_transaction_required", "snapshot_validation_required", "plan_token_validation_required", "numeric_domain_required", "unknown_field", "select_required", "filter", "filter_disabled", "sort", "collation_required", "unsupported_regex", "unsupported_literal", "unsupported_type", "invalid_source_value", "numeric_range", "encoding", "identity_required", "duplicate_identity", "scope", "window_required", "syntax", "unsupported_syntax", "unsupported_function", "arity", "type_error", "aggregate_required", "aggregate_context", "aggregate_disabled", "paired_expression_required", "dependency_cycle", "invalid_metric", "duplicate_metric", "metric_sort", "distribution", "date_grouping", "unsupported_date_grouping", "min_count_grouping", "min_count_field", "min_count_distribution", "group_disabled", "grouping", "representative", "resource_limit", "complexity_limit", "dependency_limit", "expansion_limit", "source_limit", "stage_limit", "schema_limit", "capability_unsupported", "unexpanded_series", "invalid", "too_large", "unsupported_version"];
+type ErrorCode = (typeof ERROR_CODES)[number];
+/** One machine-readable error. */
+interface QueryErrorDetail {
+    /** A newer server may send a code this client does not know; narrow with isErrorCode. */
+    code: ErrorCode | (string & {});
+    /** Human-readable; not stable. */
+    message: string;
+    /** The field the error is about, when there is one. */
+    field?: string;
+    /** Where in the expression source the problem starts, when a server or client reports it (UTF-16 code units in TypeScript). The Go server does not set it yet. */
+    offset?: number;
+    /** The metric the error is about, when there is one. */
+    metricId?: string;
+}
+/** The JSON body of every non-2xx response from the query, computed-columns and query-snapshots handlers (Content-Type: application/json). */
+interface QueryErrorBody {
+    error: QueryErrorDetail;
+}
+
 type Align = "left" | "right" | "center";
 /** A cell renderer is resolved by name against a `RenderRegistry` (in
  *  @pythia-software/query-table-ui) or supplied inline. The type lives in core so FieldDef can
@@ -125,7 +453,7 @@ interface DerivedField<Row = any, V = unknown> {
 type FieldSource<Row = any, V = unknown> = BackendField | DerivedField<Row, V>;
 /** How filter-value candidates are offered. Autocomplete is the DEFAULT for
  *  every field (design feedback): the value input is a combobox backed by
- *  Transport.fetchDistinctValues, which takes a search string so large domains
+ *  a v3 `distinct` request, which takes a search string so large domains
  *  refine per keystroke on the backend. `static` is for closed domains you don't
  *  want a round-trip for; `freeform` opts out of suggestions entirely. */
 type FilterValues = {
@@ -309,16 +637,14 @@ declare function formulaRuntime(ast: FormulaNode, inputs: Record<string, Formula
     kind: "call";
 }>) => FormulaResult | undefined): FormulaResult;
 
-type MetricValue = number | string | boolean | null;
 type MetricKey = MetricValue;
-type MetricScope = "allMatching" | "shownRows";
 /** Calendar intervals: each bucket is one interval on the timeline, keyed by
  * its start as an ISO instant. */
-type MetricCalendarInterval = "hour" | "day" | "week" | "month" | "year";
+type MetricCalendarInterval = CalendarGroupKey["interval"];
 /** Cyclic intervals: each bucket is one slot of a repeating cycle, keyed by a
  * number. `hourOfDay` is the local hour, 0–23; `dayOfWeek` the ISO weekday,
  * 1 (Monday) to 7 (Sunday). */
-type MetricCycleInterval = "hourOfDay" | "dayOfWeek";
+type MetricCycleInterval = Exclude<WireMetricDateGrouping["interval"], MetricCalendarInterval>;
 /** Summarise each cyclic slot over its occurrences: every whole day or hour
  * the slot covers inside the query's time bounds. */
 interface MetricDateOccurrence {
@@ -328,20 +654,11 @@ interface MetricDateOccurrence {
      * SUM metrics, no value for other expressions. false leaves them out. */
     includeEmpty: boolean;
 }
-/** Calendar grouping, currently executed over complete local populations. */
-interface MetricDateGrouping {
-    field: string;
+/** Calendar grouping, currently executed over complete local populations.
+ * The wire subset is WireMetricDateGrouping; whole intervals and occurrences
+ * are planned on the client. */
+interface MetricDateGrouping extends WireMetricDateGrouping {
     interval: MetricCalendarInterval | MetricCycleInterval;
-    /** IANA timezone identifier; omitted settings retain UTC behavior. */
-    timeZone?: string;
-    /** Add a bucket for every interval of the range, or for every slot of a
-     * cyclic interval. */
-    includeEmpty: boolean;
-    /** The calendar range empty intervals fill; for a cyclic interval, the range
-     * whose empty occurrences count. */
-    range: "query" | "observed" | "custom";
-    start?: string;
-    end?: string;
     /** "exclude" leaves out intervals the query's bounds cut, and intervals that
      * have not ended by the evaluation time; omitted includes them. A cyclic
      * interval's intervals are its hours or days. */
@@ -371,15 +688,11 @@ type MetricShare = "total" | "group0";
  *  non-null values of one field (like COUNT_DISTINCT), or the sum of one
  *  numeric field (like SUM; nulls add nothing). Exactly one of `distinct` and
  *  `sum` is set. A group whose measure is an error is kept. */
-type MetricMinCountOf = {
-    min: number;
-    distinct: string;
+type MetricMinCountOf = (MetricMinCountDistinct & {
     sum?: never;
-} | {
-    min: number;
-    sum: string;
+}) | (MetricMinCountSum & {
     distinct?: never;
-};
+});
 interface MetricValueFormat {
     kind: "number" | "percent" | "duration" | "date" | "time" | "datetime";
     decimals?: number;
@@ -431,82 +744,17 @@ interface MetricLayout {
     minWidthRem: number;
     minHeightRem: number;
 }
-interface MetricDistribution {
-    kind: "box" | "histogram";
-    input: string;
-    whiskers?: "minmax" | "tukey";
-    bins?: number;
-}
-interface MetricSort {
-    key: "value" | "y" | "count" | "samples" | `group${number}`;
-    dir: "asc" | "desc";
-    nulls?: "first" | "last";
-}
-interface MetricBoxSummary {
-    n: number;
-    min: number;
-    q1: number;
-    median: number;
-    q3: number;
-    max: number;
-    mean: number;
-    low: number;
-    high: number;
-    outliers: number[];
-    outlierCount: number;
-    whiskers: "minmax" | "tukey";
-    method: "exact-linear";
-}
+type MetricSort = WireMetricSort;
 /** One histogram bin: `min <= value < max`, or `<= max` for the final bin. */
 interface MetricHistogramBin {
     min: number;
     max: number;
     inclusiveMax: boolean;
 }
-type MetricDistributionResult = {
-    kind: "box";
-    summary: MetricBoxSummary | null;
-} | {
-    kind: "histogram";
-    edges: number[];
-    counts: number[];
-    n: number;
-};
 interface MetricDiagnostic extends FormulaDiagnostic {
     metricId?: string;
     code?: string;
 }
-/** Host must enforce snapshot against the row response; this token alone does not pin data. */
-interface MetricQuery {
-    /** The table's host-owned state when `hostQuery` is configured. */
-    hostState?: HostQueryState;
-    snapshot?: string;
-    profile?: string;
-    expectedRevisions?: Record<string, string>;
-    planToken?: string;
-    version: 2;
-    where: WhereTerm[];
-    orderBy: OrderByClause[];
-    limit: number;
-    offset: number;
-    metrics: AggregationClause[];
-    diagnostics: MetricDiagnostic[];
-}
-interface MetricCapabilities {
-    version: 2;
-    expressions?: boolean;
-    shownRows?: boolean;
-    distributions?: boolean;
-    computedFields?: boolean;
-    /** Executes AggregationClause.where. Clauses using it are refused otherwise. */
-    filters?: boolean;
-    /** Executes AggregationClause.minCount and reports hiddenGroups. */
-    minCount?: boolean;
-    /** Also executes an object minCount: distinct values or a sum per group. */
-    minCountMeasures?: boolean;
-    maxGroups?: number;
-    profile?: string;
-}
 
 /** Formats change presentation only; values retain their original types/units. */
 type PropertyFormat = MetricValueFormat | {
@@ -591,19 +839,7 @@ declare function discoverFieldRelationships<Row>(fields: FieldDef<Row>[], keys:
 
 /** Calendar intervals a grouping key can bucket a datetime field by. */
 declare const GROUP_KEY_INTERVALS: readonly MetricCalendarInterval[];
-/** A grouping key that buckets a datetime field by calendar interval: one
- * group per interval, keyed by the interval's start as an ISO instant. The
- * result column is named after the field. Intervals follow the metric
- * calendar (`dateGrouping`), including daylight-saving changes; weeks start
- * on Monday. */
-interface CalendarGroupKey {
-    field: string;
-    interval: MetricCalendarInterval;
-    /** IANA timezone identifier; omitted means UTC. */
-    timeZone?: string;
-}
-/** A field name (group by its exact value) or a calendar key. */
-type GroupKey = string | CalendarGroupKey;
+
 declare function isCalendarGroupKey(key: GroupKey): key is CalendarGroupKey;
 /** The source field a key reads; also the name of its result column. */
 declare function groupKeyField(key: GroupKey): string;
@@ -636,7 +872,7 @@ interface ApplyPatchOptions {
     replacing?: QueryPatch;
 }
 /** Compare a query with a patch. Both are normalized first; column widths,
- * `fitToScreen`, labels, metric display/layout and metric IDs are ignored.
+ * `fit`, labels, metric display/layout and metric IDs are ignored.
  *
  * - `active`: every owned facet matches.
  * - `modified`: some owned facet differs, but the patch is still recognizable:
@@ -813,9 +1049,6 @@ declare function prepareGrouping<Row>(rows: Row[], schema: FieldSchema<Row>, gro
     schema: FieldSchema<GroupedRow>;
 };
 
-/** All filter operators across both source projects, unioned. Every value can
- *  be NULL, so `is_null`/`is_not_null` are valid for every field type. */
-type FilterOp = "=" | "!=" | ">" | ">=" | "<" | "<=" | "contains" | "starts_with" | "ends_with" | "matches_regex" | "not_matches_regex" | "length_gt" | "length_lt" | "length_eq" | "includes" | "is_null" | "is_not_null";
 /** A single filter predicate (a "literal" in CNF terms). `value` is always the
  *  raw string the UI captured; coercion to number/bool/date happens at
  *  apply/compile time based on the field's declared type (never on the value's
@@ -829,11 +1062,8 @@ type FilterOp = "=" | "!=" | ">" | ">=" | "<" | "<=" | "contains" | "starts_with
  *  `=`→`!=`, `is_null`→`is_not_null`, `matches_regex`→`not_matches_regex`) — see
  *  `negateClause` in ops.ts. NOT is null-exclusive: a NULL/empty value satisfies
  *  neither the predicate nor its negation, matching `not_matches_regex`. */
-interface WhereClause {
-    field: string;
-    op: FilterOp;
-    value: string;
-    negated?: boolean;
+interface WhereClause extends WireWhereClause {
+    /** Presentation only; stripped before a request is sent. */
     setFilter?: SetFilterMetadata;
 }
 type SetFilterMode = "any" | "all" | "none" | "empty";
@@ -897,22 +1127,6 @@ declare function predicatesOf(term: WhereTerm): WhereClause[];
  *  some branch matches. A literal is `[[literal]]`, an OR group one
  *  single-literal branch per member. */
 declare function branchesOf(term: WhereTerm): WhereClause[][];
-/** One ORDER BY term. Array order in `QueryState.orderBy` is the sort priority. */
-interface OrderByClause {
-    field: string;
-    dir: "asc" | "desc";
-    /** NULL placement. Omitted = "last" (the historical default both projects used,
-     *  preserved so old `?q=` links round-trip identically). */
-    nulls?: "first" | "last";
-    /** Sort by the first capture group of a regex match (or by the whole match
-     *  when the pattern has no capture group). A non-match produces NULL. Regex
-     *  syntax is interpreted by the executor (JavaScript locally, PostgreSQL on
-     *  the bundled Go backend), so portable patterns should use their common
-     *  syntax subset. */
-    extract?: {
-        regex: string;
-    };
-}
 /** One column in the SELECT list, plus the view state that travels with it.
  *  Order in `QueryState.select` is the left-to-right display order. */
 interface SelectColumn {
@@ -924,11 +1138,6 @@ interface SelectColumn {
      *  and `display`; other surfaces (details, menus, metrics) keep the field's. */
     display?: CellDisplay;
 }
-/** A single aggregate operation. `count` is the only op that needs no measure
- *  column (it counts rows); the rest reduce one column's values. The server-side
- *  matrix (backends/go aggOpAllowed + the TS AGG_OPS_BY_TYPE) decides which ops a
- *  field's type permits. */
-type AggOp = "count" | "count_distinct" | "sum" | "avg" | "min" | "max";
 /** One optional "metric" pinned above the table: a single aggregate over a single
  *  measure column, optionally broken down by one or more group columns.
  *
@@ -1001,18 +1210,6 @@ interface ItemDetailsState {
     /** Record-specific JSON presentation; independent of property instance/layout IDs. */
     jsonInspections?: ScopedJsonInspectionState[];
 }
-/**
- * Query state a host owns and registers with `useQueryTable({ hostQuery })`,
- * such as a keyword clause it runs itself. It travels with the table query
- * through saves, links, history and resets as one definition. `params` are
- * named lists of strings, like URL search parameters; the host's own
- * `normalize` interprets them. Version 0 marks a payload that could not be
- * read, and is always rejected on restore.
- */
-interface HostQueryState {
-    version: number;
-    params: Record<string, string[]>;
-}
 declare const MAX_HOST_QUERY_PARAMS = 64;
 declare const MAX_HOST_QUERY_VALUES = 64;
 declare const MAX_HOST_QUERY_VALUE_LENGTH = 4000;
@@ -1020,6 +1217,8 @@ declare const MAX_HOST_QUERY_STATE_BYTES: number;
 /** Validates host state and returns its canonical form (parameters sorted by
  * name, values in order). Throws on a malformed or oversized payload. */
 declare function parseHostQueryState(input: unknown): HostQueryState;
+/** Live column sizing mode; see `QueryState.fit`. */
+type FitMode = "content" | "screen";
 interface QueryState {
     /** Host-owned state registered through `useQueryTable({ hostQuery })`.
      * Only the top-level query carries it; a grouping source never does. */
@@ -1031,9 +1230,13 @@ interface QueryState {
     itemDetails?: ItemDetailsState;
     /** Ordered SELECT list + per-column widths. Empty = the schema's default columns. */
     select: SelectColumn[];
-    /** Refit columns to each viewer's table viewport after loading. Manual width
-     *  changes clear this view preference; omitted/false uses stored widths. */
-    fitToScreen?: boolean;
+    /** Live sizing for columns without an explicit `width`, refit after every
+     *  change to what the table shows and kept out of the query:
+     *  - `"content"`: each column fits its widest drawn value.
+     *  - `"screen"`: the columns fill each viewer's table viewport.
+     *  Omitted: stored or default widths. A legacy `fitToScreen: true` (whose
+     *  stored widths were never shown) normalizes to `"screen"` without widths. */
+    fit?: FitMode;
     /** WHERE in conjunctive normal form: the AND of these terms, each a single
      *  predicate or an OR group. A flat list of literals (no groups) is the common
      *  case and the legacy shape, decoded unchanged. */
@@ -1145,10 +1348,55 @@ declare function isMeasurable(field: FieldDef): boolean;
  *  default off, but `aggregate.groupable: true` opts any backend field in. */
 declare function isGroupable(field: FieldDef): boolean;
 
+/** Whether `value` is a code this build knows. Servers may send newer codes;
+ * QueryError keeps them as strings. */
+declare const isErrorCode: (value: unknown) => value is ErrorCode;
+interface QueryErrorOptions {
+    field?: string;
+    offset?: number;
+    metricId?: string;
+    /** The HTTP status, for errors read from a response. */
+    status?: number;
+    /** The capability flag a client-side refusal needs. */
+    capability?: keyof QueryCapabilitiesV3;
+    cause?: unknown;
+}
+/** An error with a stable code, from the server (QueryErrorBody) or from a
+ * client-side refusal before any request is sent. Messages are for people;
+ * match on `code`. */
+declare class QueryError extends Error {
+    /** An ErrorCode, or a newer code this build does not know (narrow with
+     * isErrorCode before an exhaustive switch). */
+    readonly code: ErrorCode | (string & {});
+    readonly field?: string;
+    readonly offset?: number;
+    readonly metricId?: string;
+    readonly status?: number;
+    readonly capability?: keyof QueryCapabilitiesV3;
+    constructor(code: ErrorCode | (string & {}), message: string, options?: QueryErrorOptions);
+    /** The QueryErrorDetail wire shape of this error. */
+    toJSON(): QueryErrorDetail;
+}
+declare const isQueryError: (error: unknown) => error is QueryError;
+/** The code a bare HTTP status implies, for bodies that are not a
+ * QueryErrorBody (a proxy's error page, say). */
+declare function errorCodeForStatus(status: number): ErrorCode;
+/** Reads a QueryErrorBody, or null when `body` is not one. */
+declare function parseQueryErrorBody(body: unknown): QueryErrorDetail | null;
+/** A QueryError from a QueryErrorBody (or a code and message). */
+declare function queryErrorFromBody(body: unknown, status?: number): QueryError | null;
+/** The QueryError of a failed fetch response: its QueryErrorBody when it has
+ * one, otherwise a code from the status and a short message. Consumes the body. */
+declare function queryErrorFromResponse(response: Response): Promise<QueryError>;
+/** A failed metric entry. A QueryError keeps its code; any other failure of
+ * a local engine is `fallback`. */
+declare function failedMetric(id: string, error: unknown, fallback: ErrorCode): AggregationResultEntry;
+
 declare const MAX_QUERY_STATE_BYTES: number;
-declare class QueryDecodeError extends Error {
-    readonly code: "invalid" | "too_large" | "unsupported_version";
-    constructor(code: "invalid" | "too_large" | "unsupported_version", message: string);
+/** A query link or saved state that cannot be decoded; a QueryError with a query-link code. */
+declare class QueryDecodeError extends QueryError {
+    readonly code: Extract<ErrorCode, "invalid" | "too_large" | "unsupported_version">;
+    constructor(code: Extract<ErrorCode, "invalid" | "too_large" | "unsupported_version">, message: string);
 }
 /** v2 JSON or raw-DEFLATE UTF-8, whichever produces the shorter URL token. */
 declare function encodeQuery(q: QueryState): string;
@@ -1157,50 +1405,17 @@ declare function encodeQuery(q: QueryState): string;
 declare function decodeQuery(token: string): QueryState;
 /** Navigation uses this decoder so corrupt links cannot silently run defaults. */
 declare function decodeQueryStrict(token: string): QueryState;
-/** The backend request derived from a QueryState + its schema. Mirrors the Go
- *  `WireQuery`. View-only state (column widths) is intentionally absent. */
-interface ServerQuery {
-    /** field names to return — visible columns ∪ fields referenced by where/orderBy. */
-    select: string[];
-    /** only terms whose every predicate is on a pushdown-filterable field. */
-    where: WhereTerm[];
-    /** only terms on server-sortable fields, with `field` already remapped to the
-     *  field's server sort key (FieldDef.sort.field) when set. */
-    orderBy: OrderByClause[];
-    limit: number;
-    offset: number;
-    /** The table's host-owned state when `hostQuery` is configured; hosts run
-     *  their own clauses from it. Query Table does not interpret it. */
-    hostState?: HostQueryState;
-}
+
 /** Project a QueryState into the server request, dropping client-only filters,
  *  client-only sorts, and remapping sort fields through `sort.field`. */
 declare function toServerQuery<Row>(q: QueryState, schema: FieldSchema<Row>): ServerQuery;
-/** The backend request for the metric panel. Scope is the whole filtered set:
- *  the SAME pushdown WHERE as the rows query, but NO ORDER BY / LIMIT / OFFSET —
- *  metrics describe every matching row, not the visible page. Mirrors the Go
- *  AggSpec list. */
-interface AggregationRequest {
-    /** The table's host-owned state when `hostQuery` is configured. */
-    hostState?: HostQueryState;
-    diagnostics?: MetricDiagnostic[];
-    where: WhereTerm[];
-    aggregations: AggregationClause[];
-}
-/** One group's result. `keys` has one entry per AggregationClause.groupBy field,
- *  in axis order (`[]` for a grand total); a null key is the NULL/empty bucket. */
-interface AggregationBucket {
-    keys: MetricKey[];
-    error?: string;
-    y?: MetricValue;
-    yError?: string;
+/** One group's result: the wire bucket (`MetricBucketV3`) plus state the
+ *  client derives after a transport returns. */
+interface AggregationBucket extends MetricBucketV3 {
     components?: {
         expression: string;
         value: MetricValue;
     }[];
-    nullCount?: number;
-    inputErrorCount?: number;
-    distribution?: MetricDistributionResult;
     /** Client-side only: set by the metric UI when one histogram bin of this
      *  cohort is inspected (`count`/`value` are then the bin's count). Never part
      *  of a transport result. */
@@ -1211,38 +1426,15 @@ interface AggregationBucket {
     /** Occurrences summarised by a cyclic slot (`dateGrouping.occurrence`):
      *  those with a value, the samples of its mean and box. */
     occurrences?: number;
-    /** The metric: a number for count/sum/avg, or the column's value for min/max
-     *  (which may be a string for text/datetime). null when undefined (e.g. avg of
-     *  an all-null column). */
-    value: MetricValue;
-    /** COUNT(*) of rows in the group — always present, even when `value` isn't a
-     *  count, so the panel can show group sizes / shares. */
-    count: number;
 }
-interface AggregationResultEntry {
-    /** Exact omitted additive quantity; unavailable for ratios/averages/distinct. */
+interface AggregationResultEntry extends MetricResultV3 {
     other?: AggregationBucket;
-    error?: string;
-    scope?: MetricScope;
-    processedRows?: number;
-    groupCount?: number;
-    coverage?: "exact" | "partial";
-    /** Groups removed by AggregationClause.minCount (present whenever it is set).
-     *  They are not part of `groupCount`, `buckets` or `other`. */
-    hiddenGroups?: number;
-    /** Echoes AggregationClause.id. */
-    id: string;
     buckets: AggregationBucket[];
 }
 interface AggregationResult {
     /** One entry per requested aggregation, in request order. */
     metrics: AggregationResultEntry[];
 }
-/** Project a QueryState into the metric request: the pushdown WHERE subset (same
- *  rule as toServerQuery) plus the aggregations whose measure + group fields are
- *  all server-capable backend columns. Aggregations referencing a derived /
- *  unknown field are dropped — the server has no SQL for them. */
-declare function toAggregationQuery<Row>(q: QueryState, schema: FieldSchema<Row>): AggregationRequest;
 
 interface QuerySnapshot {
     version: 1;
@@ -1356,25 +1548,7 @@ interface ColumnPreview {
     errors: number;
 }
 declare function groupPreview(dependencies: string[], inputs: Record<string, FormulaValue>[], results: FormulaResult[], total: number): ColumnPreview;
-/** Server-issued capabilities are hints for client planning, never authorization. */
-interface ComputedFieldCapabilities {
-    /** Host-approved canonical predicates; omitted retains the closed default. */
-    filter?: boolean;
-    type: FieldType;
-    select: boolean;
-    sort: boolean;
-    measure: boolean;
-    group: boolean;
-    reason?: string;
-}
-interface ComputedExecution {
-    profile: string;
-    planToken: string;
-    resolvedRevisions: Record<string, string>;
-    fields: Record<string, ComputedFieldCapabilities>;
-    fingerprint?: string;
-    snapshot?: string;
-}
+
 type RowComputedValues = Record<string, {
     value: MetricValue;
     error?: {
@@ -1454,7 +1628,6 @@ interface MetricPopulationSupport {
 declare function metricPopulationError(clause: Pick<AggregationClause, "where" | "minCount">, support: MetricPopulationSupport): string | undefined;
 declare function metricDependencies(c: AggregationClause, schema: FieldSchema, resolve?: (name: string) => FormulaPlan | undefined): string[];
 declare function metricComputationKey(clauses: readonly AggregationClause[]): string;
-declare function toMetricQuery<Row>(q: QueryState, schema: FieldSchema<Row>, execution?: ComputedExecution): MetricQuery;
 /** Safe pre-worker page selection. A supplied committed page needs no query execution.
  * Query regex is never executed here; all-matching regex filtering is unsupported. */
 declare function selectMetricShownRows<Row>(rows: Row[], q: QueryState, schema: FieldSchema<Row>, options?: MetricEvaluationOptions<Row>): Row[];
@@ -1503,87 +1676,8 @@ declare function matchesClause<Row>(row: Row, clause: WhereClause, schema: Field
  *  backends/go's aggregate compile on op semantics. */
 declare function applyAggregations<Row>(rows: Row[], q: QueryState, schema: FieldSchema<Row>, options?: MetricEvaluationOptions<Row>): AggregationResult;
 
-/** Versioned row projection keeps server-computed payload separate from host row fields. */
-interface ServerQueryV2 extends ServerQuery {
-    version: 2;
-    profile: string;
-    expectedRevisions: Record<string, string>;
-    planToken?: string;
-    /** Host must enforce this binding against the row response. */
-    snapshot?: string;
-    diagnostics: MetricDiagnostic[];
-}
-interface FetchRowsResultV2<Row> {
-    version: 2;
-    rows: Row[];
-    total: number;
-    computed: {
-        id: RowId;
-        values: RowComputedValues;
-    }[];
-    execution: ComputedExecution;
-}
-/** Project with a previously resolved server capability envelope. This does not
- * authorize definitions or upload their source; the backend revalidates revisions. */
-declare function toServerQueryV2<Row>(q: QueryState, schema: FieldSchema<Row>, execution: ComputedExecution): ServerQueryV2;
-
-interface QueryCapabilitiesV3 {
-    version: 3;
-    groupedRows: boolean;
-    calendarGrouping: boolean;
-    /** Executes the cyclic `hourOfDay` and `dayOfWeek` date intervals. */
-    calendarCycles?: boolean;
-    /** Executes calendar grouping keys (`{ field, interval, timeZone }`) in a
-     * grouping stage. Requests using them are refused otherwise. */
-    calendarGroupKeys?: boolean;
-    computedSourceFilters: boolean;
-    regex: boolean;
-    regexSourceFilters?: boolean;
-    regexAggregateExpressions?: boolean;
-    /** Executes AggregationClause.where; clauses using it are refused otherwise. */
-    metricFilters?: boolean;
-    /** Executes AggregationClause.minCount and reports hiddenGroups. */
-    metricMinCount?: boolean;
-    /** Also executes an object minCount: distinct values or a sum per group. */
-    metricMinCountMeasures?: boolean;
-    maxRows: number;
-    maxGroups: number;
-    maxPopulation: number;
-    profile: string;
-}
-interface QueryRequestV3 {
-    /** The table's host-owned state when `hostQuery` is configured. */
-    hostState?: HostQueryState;
-    version: 3;
-    profile: string;
-    now: number;
-    expectedRevisions: Record<string, string>;
-    planToken?: string;
-    snapshot?: string;
-    source: ServerQuery;
-    result: ServerQuery;
-    grouping?: GroupingDefinition;
-    rows: boolean;
-    metrics: AggregationClause[];
-    diagnostics: string[];
-}
-interface QueryResultV3 {
-    version: 3;
-    now: number;
-    sourceTotal: number;
-    rows: Record<string, unknown>[];
-    total: number;
-    schema: {
-        name: string;
-        idField: string;
-        fields: {
-            name: string;
-            type: string;
-        }[];
-    };
-    metrics: AggregationResult["metrics"];
-    execution: ComputedExecution;
-}
+declare const MAX_DISTINCT_LIMIT = 500;
+declare const MAX_DISTINCT_SEARCH_LENGTH = 2000;
 /** The handshake supplies authority, including capabilities for computed keys
  * absent from the base schema. Labels may be supplied by the editable catalogue. */
 declare function sourceExecutionSchema<Row>(schema: FieldSchema<Row>, execution?: ComputedExecution, catalogue?: readonly {
@@ -1591,37 +1685,62 @@ declare function sourceExecutionSchema<Row>(schema: FieldSchema<Row>, execution?
     label: string;
     revision: string;
 }[]): FieldSchema<Row>;
+/** The v3 request for a query. Throws a QueryError, before anything is sent,
+ * when the query needs a capability the server does not advertise or would
+ * leave a filter or sort on the client (see docs/errors.md). */
 declare function toQueryRequestV3<Row>(query: QueryState, baseSchema: FieldSchema<Row>, capabilities: QueryCapabilitiesV3, execution?: ComputedExecution, options?: {
     now?: number;
     rows?: boolean;
 }): QueryRequestV3;
 declare function validateQueryResultV3(result: QueryResultV3, request: QueryRequestV3, schema: FieldSchema): void;
-
-interface FetchRowsResult<Row> {
-    rows: Row[];
-    /** Total matching rows before pagination (for "N of M" + paging bounds). */
-    total: number;
-}
-/** A keystroke-driven distinct-value lookup. Autocomplete is the DEFAULT value
- *  source for every field (design feedback), so this is how the filter combobox
- *  finds options. `search` is the user's current input; the backend returns the
- *  best matches and whether it truncated (so the UI can prompt "keep typing"). */
-interface DistinctValuesQuery {
-    field: string;
-    /** Current substring/prefix the user has typed (empty = top values). */
-    search: string;
-    /** Max suggestions to return (default chosen by the adapter, ~50). */
-    limit?: number;
-    /** The table's host-owned state when `hostQuery` is configured. */
+interface AuxiliaryRequestOptions {
+    /** Evaluation clock; defaults to Date.now(). */
+    now?: number;
+    /** The computed execution handshake, when the table has one. */
+    execution?: ComputedExecution;
     hostState?: HostQueryState;
 }
+/** Filter autocomplete: distinct values of `field` over `where` (default: the
+ * whole source). */
+declare function toDistinctRequestV3(field: string, search: string, capabilities: QueryCapabilitiesV3, options?: AuxiliaryRequestOptions & {
+    limit?: number;
+    where?: WhereTerm[];
+}): QueryRequestV3;
+declare function readDistinctResultV3(result: QueryResultV3, request: QueryRequestV3, schema: FieldSchema): DistinctResultV3;
+declare function fetchDistinctValuesV3(transport: Transport, schema: FieldSchema, field: string, search: string, options?: AuxiliaryRequestOptions & {
+    limit?: number;
+    where?: WhereTerm[];
+}, signal?: AbortSignal): Promise<DistinctResultV3>;
+/** The backend fields a single-row lookup returns by default: every
+ * selectable backend field, and the identity. */
+declare function rowLookupFields(schema: FieldSchema): string[];
+/** One row by identity (a refresh after a mutation, or an item lookup). It
+ * asks for two rows, within the server's row budget; the total reports a
+ * duplicate identity either way. */
+declare function toRowRequestV3(schema: FieldSchema, id: RowId, capabilities: QueryCapabilitiesV3, options?: AuxiliaryRequestOptions & {
+    select?: string[];
+}): QueryRequestV3;
+/** The matching row, or null when none matches. Two matches are an error. */
+declare function readRowResultV3<Row = Record<string, unknown>>(result: QueryResultV3, request: QueryRequestV3, schema: FieldSchema): Row | null;
+declare function fetchRowV3<Row = Record<string, unknown>>(transport: Transport, schema: FieldSchema, id: RowId, options?: AuxiliaryRequestOptions & {
+    select?: string[];
+}, signal?: AbortSignal): Promise<Row | null>;
+/** Field-picker statistics as ungrouped metrics: `<field>:distinct`, and
+ * `<field>:min`/`<field>:max` where the field allows them. Fields without a
+ * measurable backend source are left out. */
+declare function toFieldStatsRequestV3(schema: FieldSchema, fields: string[], capabilities: QueryCapabilitiesV3, options?: AuxiliaryRequestOptions): QueryRequestV3;
+declare function readFieldStatsResultV3(result: QueryResultV3, request: QueryRequestV3, schema: FieldSchema): Record<string, FieldStats>;
+/** Requests run in batches of at most MAX_AGGREGATIONS metrics. */
+declare function fetchFieldStatsV3(transport: Transport, schema: FieldSchema, fields: string[], options?: AuxiliaryRequestOptions, signal?: AbortSignal): Promise<Record<string, FieldStats>>;
+
+/** Filter-value suggestions: the best matches for a search and whether more
+ *  exist (so the UI can prompt "keep typing"). */
 interface DistinctValuesResult {
     values: string[];
     /** true when more matches exist than were returned — refine by typing. */
     hasMore: boolean;
     /** True if the selected field has at least one NULL in the source dataset.
-     *  False if that field is guaranteed non-null. Omitted when the backend does
-     *  not compute this metadata. */
+     *  False if that field is guaranteed non-null. Omitted when unknown. */
     hasNull?: boolean;
 }
 /** Per-field metadata for the field picker. */
@@ -1630,32 +1749,13 @@ interface FieldStats {
     min?: string | number;
     max?: string | number;
 }
+/** Remote execution. Every row page, metric batch, grouped view, filter
+ *  suggestion, row lookup and field statistic is one v3 request. Omit the
+ *  transport to run `clientRows` locally. */
 interface Transport<Row = any> {
-    queryCapabilities?: QueryCapabilitiesV3;
-    fetchQueryV3?(query: QueryRequestV3, signal?: AbortSignal): Promise<QueryResultV3>;
-    fetchRowsV2?(query: ServerQueryV2, signal?: AbortSignal): Promise<FetchRowsResultV2<Row>>;
-    metricCapabilities?: MetricCapabilities;
-    fetchMetrics?(query: MetricQuery, signal?: AbortSignal): Promise<AggregationResult>;
-    /** Legacy row execution. A remote table needs this, fetchRowsV2 with a
-     * computedExecution handshake, or fetchQueryV3 with queryCapabilities.
-     * Modern hosts may omit the legacy endpoint, including for draft previews. */
-    fetchRows?(query: ServerQuery, signal?: AbortSignal): Promise<FetchRowsResult<Row>>;
-    /** Distinct values for filter autocomplete. Strongly recommended: without it,
-     *  fields fall back to freeform input. The backend should match `search`
-     *  server-side (e.g. ILIKE prefix) and cap at `limit` so large domains stay
-     *  fast and refine per keystroke. */
-    fetchDistinctValues?(q: DistinctValuesQuery, signal?: AbortSignal): Promise<DistinctValuesResult>;
-    /** Run the metric panel's GROUP BY queries (one per requested aggregation),
-     *  scoped to the WHERE-filtered set with no paging. Optional: without it, the
-     *  metric panel falls back to applyAggregations over local rows (client mode).
-     *  Implementations compile each AggSpec with backends/go CompileAggregation,
-     *  sharing the same WHERE as fetchRows. */
-    fetchAggregations?(q: AggregationRequest, signal?: AbortSignal): Promise<AggregationResult>;
-    /** Re-fetch a single row by id, for in-place updates without a full re-query
-     *  after a mutation. Optional. */
-    fetchRow?(id: RowId, signal?: AbortSignal): Promise<Row | null>;
-    /** Stats for the field picker. Optional. */
-    fetchFieldStats?(fields: string[], signal?: AbortSignal): Promise<Record<string, FieldStats>>;
+    /** The server's negotiated v3 capabilities and profile. */
+    queryCapabilities: QueryCapabilitiesV3;
+    fetchQueryV3(query: QueryRequestV3, signal?: AbortSignal): Promise<QueryResultV3>;
 }
 interface SavedQuery {
     snapshotCode?: string;
@@ -1943,4 +2043,4 @@ declare function attentionTargetKey(target: AttentionTarget): string;
 /** Framework-independent registration and cancellation; adapters own materialization. */
 declare function createAttentionRegistry(): AttentionRegistry;
 
-export { AGG_OPS_BY_TYPE, AGG_OPS_NEEDING_FIELD, type AggOp, type AggregateConfig, type AggregationBucket, type AggregationClause, type AggregationRequest, type AggregationResult, type AggregationResultEntry, type Align, type ApplyPatchOptions, type ApplyResult, type AttentionProvider, type AttentionRegistry, type AttentionResult, type AttentionTarget, type BackendField, COMPUTED_PREFIX, type CalendarGroupKey, type CellDisplay, type CellRenderer, type ColumnPreview, type ComputedCellError, type ComputedColumn, type ComputedColumnDraft, type ComputedColumnStore, type ComputedExecution, type ComputedFieldCapabilities, type DerivedField, type DistinctValuesQuery, type DistinctValuesResult, EMPTY_QUERY, FORMULA_FUNCTIONS, type FetchRowsResult, type FetchRowsResultV2, type FieldDef, type FieldOrigin, type FieldRelationship, type FieldSchema, type FieldSource, type FieldStats, type FieldType, type FilterConfig, type FilterOp, type FilterValues, type ForeignKey, type FormulaDiagnostic, FormulaError, type FormulaFunction, type FormulaNode, type FormulaPlan, type FormulaResult, type FormulaType, type FormulaValue, GROUP_ID_FIELD, GROUP_KEY_INTERVALS, GROUP_LINK_RENDER, type GroupKey, type GroupLinkValue, type GroupedRow, type GroupingDefinition, type GroupingModel, type GroupingState, type GroupingView, type HostQueryState, ITEM_DETAILS_COLUMN, type ItemDetailMode, type ItemDetailsState, type ItemPageOptions, type ItemPropertyMode, type JsonCellDisplay, type JsonInspectionScope, type JsonInspectionState, type JsonMatchIdentity, type LinkDestination, type LinkSpec, type LinkTargets, MAX_AGGREGATIONS, MAX_GROUP_BY_FIELDS, MAX_HOST_QUERY_PARAMS, MAX_HOST_QUERY_STATE_BYTES, MAX_HOST_QUERY_VALUES, MAX_HOST_QUERY_VALUE_LENGTH, MAX_JSON_INSPECTIONS, MAX_JSON_PATHS, MAX_METRIC_WINDOW_PERIODS, MAX_ORDER_BY_TERMS, MAX_PROPERTIES, MAX_QUERY_LIMIT, MAX_QUERY_OFFSET, MAX_QUERY_STATE_BYTES, MAX_QUERY_TOKEN_LENGTH, MAX_RELATIVE_TIME_MS, MAX_REPRESENTATIVE_SORTS, MAX_RESULT_GROUPS, MAX_SELECT_COLUMNS, MAX_SUMMARY_COLUMNS, MAX_WHERE_CLAUSES, METRIC_CYCLE_INTERVALS, METRIC_DATE_INTERVALS, METRIC_FUNCTIONS, type MetricAxisScale, type MetricBoxSummary, type MetricCalendarInterval, type MetricCapabilities, type MetricCycleInterval, type MetricDateGrouping, type MetricDateOccurrence, type MetricDiagnostic, type MetricDisplay, type MetricDistribution, type MetricDistributionResult, type MetricEvaluationOptions, type MetricHistogramBin, type MetricKey, type MetricLayout, type MetricMinCountOf, type MetricPlan, type MetricPopulationSupport, type MetricQuery, type MetricReductionOptions, type MetricScope, type MetricSeriesOptions, type MetricSeriesPlan, type MetricShare, type MetricSort, type MetricValue, type MetricValueFormat, type MetricWindow, NULLARY_OPS, OPS_BY_TYPE, OP_LABEL, type ObjectReference, type ObjectTypeDefinition, type OpChoice, type OpPair, type OrGroup, type OrOfAndsGroup, type OrderByClause, type PreviewGroup, type PropertyFieldConfig, type PropertyFormat, type PropertySelection, type PropertyViewState, type PropertyViewStorage, type QueryCapabilitiesV3, QueryDecodeError, type QueryEvaluationOptions, type QueryFacet, type QueryLink, type QueryLinkOptions, type QueryLinkService, type QueryPatch, type QueryPatchMatch, type QueryRequestV3, type QueryResultV3, type QuerySnapshot, type QuerySnapshotCache, QuerySnapshotHttpError, type QuerySnapshotHttpErrorCode, type QuerySnapshotStore, type QueryState, type RegexInspection, type RelationshipAdapter, type RepresentativeOrder, type RepresentativeRow, type ResolvedGroupLink, type ResolvedObjectReference, type RowComputedValues, type RowId, type SavedPropertyView, type SavedQuery, type ScopedJsonInspectionState, type SelectColumn, type SelectConfig, type ServerQuery, type ServerQueryV2, type SetFilterMetadata, type SetFilterMode, type SetFilterTarget, type SortConfig, type SourceDependencies, type StorageAdapter, type SummaryColumn, type SummaryOp, type Transport, type WhereBranch, type WhereClause, type WhereConjunction, type WhereTerm, aggOpAllowedForType, aggOpNeedsField, aggOpsForField, applyAggregations, applyPatch, applyQuery, attentionTargetKey, boxSummary, branchesOf, calendarGroupKey, coerceValue, compareMetricValues, compileFormula, compileMetric, computedFieldName, createAttentionRegistry, createGroupingModel, createPropertyView, createQueryLinkService, createSetFilter, decodeQuery, decodeQueryStrict, discoverFieldRelationships, encodeQuery, evaluateMetricReductions, evaluateMetrics, exitGrouping, filterValues, formulaRuntime, groupKeyField, groupKeyFields, groupKeyTerms, groupLinkQuery, groupPreview, groupSourceQuery, hasMetricSeries, hasRegex, histogramCounts, histogramEdges, httpComputedColumnStore, httpQuerySnapshotStore, indexFields, inspectBucketQuery, isCalendarGroupKey, isComputedCellError, isComputedField, isFilterable, isGroupLinkField, isGroupLinkValue, isGroupable, isGroupingTimeZone, isJsonBucketId, isJsonPath, isMeasurable, isMetricCycle, isNegativePredicate, isOrGroup, isOrOfAndsGroup, isPropertyFieldLoaded, isPushdownFilter, isSelectable, isSortable, isWhereConjunction, isWhereGroup, itemPageFields, jsonInspectionScopeKey, jsonPropertyViewStorage, loadSchema, localPropertyViewStorage, localQuerySnapshotCache, localStorageAdapter, mapSetFilterValues, matchPatch, matchesClause, memoryComputedColumnStore, memoryPropertyViewStorage, memoryQuerySnapshotCache, memoryStorageAdapter, metricAggregatePlans, metricCalendarUnit, metricComputationKey, metricCustomEndTime, metricCycleSlot, metricCycleSlots, metricDateBounds, metricDateFloor, metricDateNext, metricDateRange, metricDateTime, metricDependencies, metricExpression, metricMinCount, metricMinCountKeeps, metricMinCountMeasure, metricMinCountPlan, metricMinCountText, metricPlans, metricPopulationError, negateClause, normalizePropertyFormat, normalizePropertyView, normalizeQueryState, objectReferenceKey, occurrenceDistribution, opAllowedForType, opPairsForField, opsForField, parseHostQueryState, parseJsonInspectionState, parseJsonInspections, parseRelativeDuration, percentile, planMetricSeries, predicatesOf, prepareGrouping, queriesEqual, readFieldValue, readObjectReference, readSetFilter, reduceMetricValues, removePatch, renderItemPageTemplate, resolveFieldName, resolveGroupLink, selectMetricShownRows, selectedFields, setFilterModes, setFilterTarget, sortMetricBuckets, sourceDependencies, sourceExecutionSchema, stripSetFilter, toAggregationQuery, toMetricQuery, toQueryRequestV3, toServerQuery, toServerQueryV2, validateComputedColumn, validateDateGrouping, validateItemPageTemplate, validateMetric, validateMetricSeries, validateQueryResultV3, validateQuerySnapshot, wholeIntervalSpan, withGroupingKeys, withoutGrouping, withoutLinkSummaries };
+export { AGG_OPS_BY_TYPE, AGG_OPS_NEEDING_FIELD, type AggOp, type AggregateConfig, type AggregationBucket, type AggregationClause, type AggregationResult, type AggregationResultEntry, type Align, type ApplyPatchOptions, type ApplyResult, type AttentionProvider, type AttentionRegistry, type AttentionResult, type AttentionTarget, type AuxiliaryRequestOptions, type BackendField, COMPUTED_PREFIX, type CalendarGroupKey, type CellDisplay, type CellRenderer, type ColumnPreview, type ComputedCellError, type ComputedColumn, type ComputedColumnDraft, type ComputedColumnStore, type ComputedExecution, type ComputedFieldCapabilities, type DerivedField, type DistinctRequestV3, type DistinctResultV3, type DistinctValuesResult, EMPTY_QUERY, ERROR_CODES, type ErrorCode, FORMULA_FUNCTIONS, type FieldDef, type FieldOrigin, type FieldRelationship, type FieldSchema, type FieldSource, type FieldStats, type FieldType, type FilterConfig, type FilterOp, type FilterValues, type FitMode, type ForeignKey, type FormulaDiagnostic, FormulaError, type FormulaFunction, type FormulaNode, type FormulaPlan, type FormulaResult, type FormulaType, type FormulaValue, GROUP_ID_FIELD, GROUP_KEY_INTERVALS, GROUP_LINK_RENDER, type GroupKey, type GroupLinkValue, type GroupedRow, type GroupingDefinition, type GroupingModel, type GroupingState, type GroupingView, type HostQueryState, ITEM_DETAILS_COLUMN, type ItemDetailMode, type ItemDetailsState, type ItemPageOptions, type ItemPropertyMode, type JsonCellDisplay, type JsonInspectionScope, type JsonInspectionState, type JsonMatchIdentity, type LinkDestination, type LinkSpec, type LinkTargets, MAX_AGGREGATIONS, MAX_DISTINCT_LIMIT, MAX_DISTINCT_SEARCH_LENGTH, MAX_GROUP_BY_FIELDS, MAX_HOST_QUERY_PARAMS, MAX_HOST_QUERY_STATE_BYTES, MAX_HOST_QUERY_VALUES, MAX_HOST_QUERY_VALUE_LENGTH, MAX_JSON_INSPECTIONS, MAX_JSON_PATHS, MAX_METRIC_WINDOW_PERIODS, MAX_ORDER_BY_TERMS, MAX_PROPERTIES, MAX_QUERY_LIMIT, MAX_QUERY_OFFSET, MAX_QUERY_STATE_BYTES, MAX_QUERY_TOKEN_LENGTH, MAX_RELATIVE_TIME_MS, MAX_REPRESENTATIVE_SORTS, MAX_RESULT_GROUPS, MAX_SELECT_COLUMNS, MAX_SUMMARY_COLUMNS, MAX_WHERE_CLAUSES, METRIC_CYCLE_INTERVALS, METRIC_DATE_INTERVALS, METRIC_FUNCTIONS, type MetricAxisScale, type MetricBoxDistribution, type MetricBoxSummary, type MetricBucketV3, type MetricCalendarInterval, type MetricCycleInterval, type MetricDateGrouping, type MetricDateOccurrence, type MetricDiagnostic, type MetricDisplay, type MetricDisplayHint, type MetricDistribution, type MetricDistributionResult, type MetricEvaluationOptions, type MetricHistogramBin, type MetricHistogramDistribution, type MetricKey, type MetricLayout, type MetricMinCount, type MetricMinCountDistinct, type MetricMinCountOf, type MetricMinCountSum, type MetricPlan, type MetricPopulationSupport, type MetricReductionOptions, type MetricResultV3, type MetricScope, type MetricSeriesOptions, type MetricSeriesPlan, type MetricShare, type MetricSort, type MetricSpecV3, type MetricValue, type MetricValueFormat, type MetricWindow, NULLARY_OPS, OPS_BY_TYPE, OP_LABEL, type ObjectReference, type ObjectTypeDefinition, type OpChoice, type OpPair, type OrGroup, type OrOfAndsGroup, type OrderByClause, type PreviewGroup, type ProjectedFieldV3, type ProjectedSchemaV3, type PropertyFieldConfig, type PropertyFormat, type PropertySelection, type PropertyViewState, type PropertyViewStorage, type QueryCapabilitiesV3, QueryDecodeError, QueryError, type QueryErrorBody, type QueryErrorDetail, type QueryErrorOptions, type QueryEvaluationOptions, type QueryFacet, type QueryLink, type QueryLinkOptions, type QueryLinkService, type QueryPatch, type QueryPatchMatch, type QueryRequestV3, type QueryResultV3, type QuerySnapshot, type QuerySnapshotCache, QuerySnapshotHttpError, type QuerySnapshotHttpErrorCode, type QuerySnapshotStore, type QueryState, type RegexExtract, type RegexInspection, type RelationshipAdapter, type RepresentativeOrder, type RepresentativeRow, type ResolvedGroupLink, type ResolvedObjectReference, type RowComputedValues, type RowId, type SavedPropertyView, type SavedQuery, type ScopedJsonInspectionState, type SelectColumn, type SelectConfig, type ServerQuery, type SetFilterMetadata, type SetFilterMode, type SetFilterTarget, type SortConfig, type SourceDependencies, type StorageAdapter, type SummaryColumn, type SummaryOp, type Transport, type WhereBranch, type WhereClause, type WhereConjunction, type WhereTerm, type WireGroupingDefinition, type WireMetricDateGrouping, type WireMetricSort, type WireOrGroup, type WireRepresentativeRow, type WireSummaryColumn, type WireWhereBranch, type WireWhereClause, type WireWhereConjunction, type WireWhereTerm, aggOpAllowedForType, aggOpNeedsField, aggOpsForField, applyAggregations, applyPatch, applyQuery, attentionTargetKey, boxSummary, branchesOf, calendarGroupKey, coerceValue, compareMetricValues, compileFormula, compileMetric, computedFieldName, createAttentionRegistry, createGroupingModel, createPropertyView, createQueryLinkService, createSetFilter, decodeQuery, decodeQueryStrict, discoverFieldRelationships, encodeQuery, errorCodeForStatus, evaluateMetricReductions, evaluateMetrics, exitGrouping, failedMetric, fetchDistinctValuesV3, fetchFieldStatsV3, fetchRowV3, filterValues, formulaRuntime, groupKeyField, groupKeyFields, groupKeyTerms, groupLinkQuery, groupPreview, groupSourceQuery, hasMetricSeries, hasRegex, histogramCounts, histogramEdges, httpComputedColumnStore, httpQuerySnapshotStore, indexFields, inspectBucketQuery, isCalendarGroupKey, isComputedCellError, isComputedField, isErrorCode, isFilterable, isGroupLinkField, isGroupLinkValue, isGroupable, isGroupingTimeZone, isJsonBucketId, isJsonPath, isMeasurable, isMetricCycle, isNegativePredicate, isOrGroup, isOrOfAndsGroup, isPropertyFieldLoaded, isPushdownFilter, isQueryError, isSelectable, isSortable, isWhereConjunction, isWhereGroup, itemPageFields, jsonInspectionScopeKey, jsonPropertyViewStorage, loadSchema, localPropertyViewStorage, localQuerySnapshotCache, localStorageAdapter, mapSetFilterValues, matchPatch, matchesClause, memoryComputedColumnStore, memoryPropertyViewStorage, memoryQuerySnapshotCache, memoryStorageAdapter, metricAggregatePlans, metricCalendarUnit, metricComputationKey, metricCustomEndTime, metricCycleSlot, metricCycleSlots, metricDateBounds, metricDateFloor, metricDateNext, metricDateRange, metricDateTime, metricDependencies, metricExpression, metricMinCount, metricMinCountKeeps, metricMinCountMeasure, metricMinCountPlan, metricMinCountText, metricPlans, metricPopulationError, negateClause, normalizePropertyFormat, normalizePropertyView, normalizeQueryState, objectReferenceKey, occurrenceDistribution, opAllowedForType, opPairsForField, opsForField, parseHostQueryState, parseJsonInspectionState, parseJsonInspections, parseQueryErrorBody, parseRelativeDuration, percentile, planMetricSeries, predicatesOf, prepareGrouping, queriesEqual, queryErrorFromBody, queryErrorFromResponse, readDistinctResultV3, readFieldStatsResultV3, readFieldValue, readObjectReference, readRowResultV3, readSetFilter, reduceMetricValues, removePatch, renderItemPageTemplate, resolveFieldName, resolveGroupLink, rowLookupFields, selectMetricShownRows, selectedFields, setFilterModes, setFilterTarget, sortMetricBuckets, sourceDependencies, sourceExecutionSchema, stripSetFilter, toDistinctRequestV3, toFieldStatsRequestV3, toQueryRequestV3, toRowRequestV3, toServerQuery, validateComputedColumn, validateDateGrouping, validateItemPageTemplate, validateMetric, validateMetricSeries, validateQueryResultV3, validateQuerySnapshot, wholeIntervalSpan, withGroupingKeys, withoutGrouping, withoutLinkSummaries };