@pythia-software/query-table-core 0.7.1 → 0.8.0

package/dist/index.d.ts

@@ -40,9 +40,13 @@ type CellDisplay = JsonCellDisplay | ({
     kind: "chip";
     labels?: Record<string, string>;
     tones?: Record<string, "neutral" | "success" | "warning" | "danger">;
-} | {
+}
+/** `truncate` keeps one line with an ellipsis. `lines` (1–20) wraps the text
+ * and clamps it to that many lines with an ellipsis; it takes precedence. */
+ | {
     kind: "text";
     truncate?: boolean;
+    lines?: number;
 };
 
 type FieldType = "text" | "number" | "enum" | "datetime" | "bool" | "textarray";
@@ -96,7 +100,8 @@ type FilterValues = {
     source: "freeform";
 };
 interface FilterConfig {
-    /** Opt into the native multi-value editor for textarray fields. */
+    /** Opt into the native multi-value editor: ANY/ALL/NONE/EMPTY for textarray
+     *  fields; ANY/NONE for enum fields and text fields with static options. */
     editor?: "set";
     /** Preserve case when matching textarray values. Default false. */
     arrayCaseSensitive?: boolean;
@@ -351,6 +356,12 @@ interface MetricBoxSummary {
     whiskers: "minmax" | "tukey";
     method: "exact-linear";
 }
+/** 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;
@@ -384,6 +395,10 @@ interface MetricCapabilities {
     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;
     maxGroups?: number;
     profile?: string;
 }
@@ -467,6 +482,45 @@ declare function readObjectReference<Row>(field: FieldDef<Row>, fields: FieldDef
 /** Only unambiguous, fully mapped constraints become links. Explicit metadata wins. */
 declare function discoverFieldRelationships<Row>(fields: FieldDef<Row>[], keys: ForeignKey[], types: ObjectTypeDefinition[]): FieldDef<Row>[];
 
+type QueryFacet = "filters" | "columns" | "order" | "grouping" | "metrics" | "limit";
+interface QueryPatch {
+    /** Host identity for the patch; not interpreted. */
+    id: string;
+    /** Facets this patch controls. Facets not listed are never touched. */
+    owns: QueryFacet[];
+    /** Values for the owned facets. A `grouping` value makes this a group-stage
+     *  patch: its `where` is HAVING and its filters are `grouping.source.where`. */
+    query: Partial<QueryState>;
+}
+interface QueryPatchMatch {
+    status: "active" | "modified" | "inactive";
+    /** Owned facets that differ; only populated when `status` is "modified". */
+    modified: QueryFacet[];
+}
+interface ApplyPatchOptions {
+    /** A previously applied patch to remove first (see `removePatch`). */
+    replacing?: QueryPatch;
+}
+/** Compare a query with a patch. Both are normalized first; column widths,
+ * `fitToScreen`, 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:
+ *   at least one owned facet matches (an owned `filters` facet with no terms
+ *   does not count), or at least one of its filter units is still present.
+ * - `inactive`: otherwise. */
+declare function matchPatch(query: QueryState, patch: QueryPatch): QueryPatchMatch;
+/** Remove a patch: its filter units that are still fully present are removed;
+ * each other owned facet that still matches the patch is reset (columns and
+ * order to the schema defaults, metrics to none, grouping exited). Facets the
+ * user has since changed, and `limit`, are left alone. Resets offsets to 0. */
+declare function removePatch(query: QueryState, patch: QueryPatch): QueryState;
+/** Apply a patch. Facets it does not own are untouched. Owned non-filter
+ * facets are replaced; owned filters are additive: units already present are
+ * not duplicated and user-authored terms are never removed. With `replacing`,
+ * that patch is first removed with `removePatch`. Resets offsets to 0. */
+declare function applyPatch(query: QueryState, patch: QueryPatch, options?: ApplyPatchOptions): QueryState;
+
 /** Portable datetime/offset bound in milliseconds (also below MAX_SAFE_INTEGER). */
 declare const MAX_RELATIVE_TIME_MS = 8640000000000000;
 /** A signed elapsed offset, e.g. -1h or +8d2h10m. The sign applies to the
@@ -481,7 +535,7 @@ interface QueryEvaluationOptions {
 
 type GroupedRow = Record<string, unknown>;
 type Row = GroupedRow;
-type SummaryOp = AggOp | "row" | "formula";
+type SummaryOp = AggOp | "row" | "formula" | "link";
 interface RepresentativeOrder {
     field: string;
     dir: "asc" | "desc";
@@ -496,7 +550,63 @@ interface SummaryColumn {
     field?: string;
     expression?: string;
     label?: string;
+    /** Cell format for this output column (for example `{ kind: "percent" }` for
+     * a weighted rate). Replaces any render/display inherited from the source
+     * field; metrics measuring the column default their value format from it. */
+    display?: CellDisplay;
+    /** Required for `op: "link"`; ignored otherwise. */
+    link?: LinkSpec;
+}
+/** Where a link column points. Placeholders and key filters read the group
+ * row: its keys and non-link summaries. */
+type LinkDestination = 
+/** `{field:name}` placeholders over keys and summaries; values are
+ * percent-encoded. The result must be an HTTP(S) or relative URL. */
+{
+    kind: "template";
+    template: string;
+}
+/** A query composed by query-table and routed by the host's
+ * `linkTargets[target](query, params)`. */
+ | {
+    kind: "query";
+    target: string;
+    /** "source" (default) starts from `grouping.source`, keeping its
+     * filters, columns and order; "empty" starts from `EMPTY_QUERY`. */
+    base?: "source" | "empty";
+    /** Add `=`/`is_null` per group key, as `groupSourceQuery` does. Default true. */
+    keyFilters?: boolean;
+    /** Applied last, with `applyPatch`. */
+    patch?: QueryPatch;
+    /** Static parameters passed to the host target. */
+    params?: Record<string, string>;
+};
+/** A group-grain link column (`SummaryColumn` with `op: "link"`). Computed on
+ * the client from the returned group row; never sent to a server. */
+interface LinkSpec {
+    /** Static text, or the value of a group key or summary column. */
+    label: string | {
+        column: string;
+    };
+    to: LinkDestination;
 }
+/** The value of a link column for one group row: everything that depends on
+ * the row. `resolveGroupLink` combines it with the current query and the
+ * host's link targets. */
+interface GroupLinkValue {
+    kind: "group-link";
+    label: string;
+    to: LinkDestination | null;
+    /** Template links: the substituted, not yet safety-checked href. */
+    href?: string;
+    /** Query links with key filters: the group's key predicates. */
+    terms?: WhereClause[];
+    /** Why the link cannot be followed for this row. */
+    problem?: string;
+}
+declare const GROUP_LINK_RENDER = "qt_group_link";
+declare function isGroupLinkValue(value: unknown): value is GroupLinkValue;
+declare function isGroupLinkField(field: Pick<FieldDef, "render"> | undefined): boolean;
 interface GroupingView {
     version: 2;
     mode: "rows" | "groups";
@@ -523,6 +633,15 @@ declare const MAX_REPRESENTATIVE_SORTS = 8;
 declare const MAX_SUMMARY_COLUMNS = 64;
 declare const MAX_RESULT_GROUPS = 10000;
 declare function withoutGrouping(query: QueryState): QueryState;
+/** Leave the grouping stage: the source snapshot restores the record WHERE,
+ * layout, ordering, paging, metrics and item details. Ungrouped queries are
+ * returned unchanged. */
+declare function exitGrouping(query: QueryState): QueryState;
+/** The grouping-key transition behind the grouping controls. Empty keys exit
+ * the stage; an ungrouped query becomes the source of a new stage that shows
+ * only its keys; a grouped query swaps keys, dropping result columns, HAVING
+ * terms and sorts on removed keys and clearing group metrics. */
+declare function withGroupingKeys(query: QueryState, keys: string[]): QueryState;
 declare const OP_LABEL: Record<SummaryOp, string>;
 /** Bind aggregation helpers to this instance's source catalogue. */
 declare function createGroupingModel<InputRow>(inputSchema: FieldSchema<InputRow>): {
@@ -536,6 +655,8 @@ declare function createGroupingModel<InputRow>(inputSchema: FieldSchema<InputRow
     summaryExpression: (column: SummaryColumn) => string;
     summaryProblem: (column: SummaryColumn) => string | null;
     summaryLabel: (column: SummaryColumn) => string;
+    linkProblem: (column: SummaryColumn, keys: string[], summaries: SummaryColumn[]) => string | null;
+    linkDiagnostics: (definition: Pick<GroupingDefinition, "keys" | "summaries">) => string[];
     resultSchema: (keys: string[], summaries: SummaryColumn[]) => FieldSchema<Row>;
     groupRows: (rows: InputRow[], schema: FieldSchema<InputRow>, keys: string[], summaries: SummaryColumn[], rule?: RepresentativeRow | null) => Row[];
     filteredInput: (rows: InputRow[], query: QueryState, schema: FieldSchema<InputRow>, options?: QueryEvaluationOptions) => InputRow[];
@@ -624,6 +745,10 @@ interface SelectColumn {
     field: string;
     /** Pixel width override. Omitted = FieldDef.select.width, else the type default. */
     width?: number;
+    /** Table-cell presentation for this column in this layout, e.g.
+     *  `{ kind: "text", lines: 3 }`. Takes precedence over the field's `render`
+     *  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
@@ -661,6 +786,15 @@ interface AggregationClause {
     groupBy: string[];
     /** Panel header override; defaults to a derived label like "avg total". */
     label?: string;
+    /** This metric's own row predicate (CNF, like `QueryState.where`), ANDed with
+     *  the table WHERE before grouping. The table rows are unchanged. In grouped
+     *  mode it refers to grouped-result fields. Shown-row metrics apply it inside
+     *  the shown page. */
+    where?: WhereTerm[];
+    /** Drop groups with fewer than this many rows (counted after `where`) before
+     *  sorting, `groupLimit` and Other. Requires at least one grouping field;
+     *  integer 1–1,000,000. Removed groups are reported as `hiddenGroups`. */
+    minCount?: number;
 }
 /** Detail affordances are presentation state, never backend SELECT fields. */
 type ItemPropertyMode = "hover" | "modal" | "expand";
@@ -736,7 +870,6 @@ declare function normalizeQueryState(input: unknown, fallback?: QueryState): Que
  *  refetch is actually needed (avoids history spam / redundant fetches). */
 declare function queriesEqual(a: QueryState, b: QueryState): boolean;
 
-/** Literal templates only: substitution never evaluates code or nested paths. */
 declare function itemPageFields(template: string): string[];
 declare function validateItemPageTemplate<Row>(template: string, schema: FieldSchema<Row>): string | null;
 declare function renderItemPageTemplate<Row>(template: string, schema: FieldSchema<Row>, row: Row, id: RowId | null, query: string): string | null;
@@ -858,6 +991,10 @@ interface AggregationBucket {
     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. */
+    bin?: MetricHistogramBin;
     /** 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). */
@@ -874,6 +1011,9 @@ interface AggregationResultEntry {
     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[];
@@ -1054,6 +1194,14 @@ declare function metricExpression(clause: AggregationClause): string;
 declare function hasRegex(plan: FormulaPlan): boolean;
 declare function metricPlans(c: AggregationClause, schema: FieldSchema, resolve?: (name: string) => FormulaPlan | undefined): FormulaPlan[];
 declare function validateMetric(c: AggregationClause, schema: FieldSchema, resolve?: (name: string) => FormulaPlan | undefined): FormulaDiagnostic[];
+/** Executor support for population controls, from either capability handshake. */
+interface MetricPopulationSupport {
+    filters?: boolean | undefined;
+    minCount?: boolean | undefined;
+}
+/** A clause the executor cannot run exactly gets its own error; it is never
+ * sent with `where`/`minCount` silently dropped. */
+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;
@@ -1134,6 +1282,10 @@ interface QueryCapabilitiesV3 {
     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;
     maxRows: number;
     maxGroups: number;
     maxPopulation: number;
@@ -1280,8 +1432,18 @@ declare function memoryStorageAdapter(): StorageAdapter;
  * datasets. Falls back to no persistence when storage is unavailable. */
 declare function localStorageAdapter(): StorageAdapter;
 
-/** Compile an explicitly identified editor into existing CNF predicates. */
-declare function createSetFilter(field: string, mode: SetFilterMode, values: string[], id: string): WhereTerm[];
+/** What a set editor compiles to: array membership (`includes`) for textarray
+ *  fields, or scalar equality (`=` / `!=`) for enum and static-option text fields. */
+type SetFilterTarget = "array" | "scalar";
+/** The set editor a field opted into with `filter.editor: "set"`, or null.
+ *  Text fields qualify only with static `filter.values.options`. */
+declare function setFilterTarget(field: FieldDef): SetFilterTarget | null;
+/** Modes a target supports. ALL and EMPTY describe arrays; a scalar holds one value. */
+declare function setFilterModes(target: SetFilterTarget): SetFilterMode[];
+/** Compile an explicitly identified editor into existing CNF predicates.
+ *  Scalar NONE keeps NULL rows: one `(is_null OR != v)` group per value, because
+ *  a bare `!=` is null-exclusive. */
+declare function createSetFilter(field: string, mode: SetFilterMode, values: string[], id: string, target?: SetFilterTarget): WhereTerm[];
 /** Remove presentation metadata at transport boundaries, including inner literals. */
 declare function stripSetFilter(term: WhereTerm): WhereTerm;
 /** Only collapse explicitly marked, intact editor output. Never infer from predicates. */
@@ -1289,6 +1451,7 @@ declare function readSetFilter(where: WhereTerm[], index: number): {
     field: string;
     metadata: SetFilterMetadata;
     count: number;
+    target: SetFilterTarget;
 } | null;
 /** Canonicalize consumer-owned value aliases without disconnecting editor metadata. */
 declare function mapSetFilterValues(where: WhereTerm[], canonicalize: (field: string, value: string) => string): WhereTerm[];
@@ -1352,4 +1515,55 @@ interface SourceDependencies {
  * inputs and transitive computed/derived dependencies, even when not selected. */
 declare function sourceDependencies<Row>(query: QueryState, schema: FieldSchema<Row>, resolveComputed?: (name: string) => FormulaPlan | undefined): SourceDependencies;
 
-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 ApplyResult, type BackendField, COMPUTED_PREFIX, 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, type GroupedRow, type GroupingDefinition, type GroupingModel, type GroupingState, type GroupingView, ITEM_DETAILS_COLUMN, type ItemDetailMode, type ItemDetailsState, type ItemPageOptions, type ItemPropertyMode, type JsonCellDisplay, MAX_AGGREGATIONS, MAX_GROUP_BY_FIELDS, 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_DATE_INTERVALS, METRIC_FUNCTIONS, type MetricAxisScale, type MetricBoxSummary, type MetricCapabilities, type MetricDateGrouping, type MetricDiagnostic, type MetricDisplay, type MetricDistribution, type MetricDistributionResult, type MetricEvaluationOptions, type MetricKey, type MetricLayout, type MetricPlan, type MetricQuery, type MetricReductionOptions, type MetricScope, type MetricSort, type MetricValue, type MetricValueFormat, NULLARY_OPS, OPS_BY_TYPE, OP_LABEL, type ObjectReference, type ObjectTypeDefinition, type OpChoice, type OpPair, type OrGroup, type OrderByClause, type PreviewGroup, type PropertyFieldConfig, type PropertyFormat, type PropertySelection, type PropertyViewState, type PropertyViewStorage, type QueryCapabilitiesV3, QueryDecodeError, type QueryEvaluationOptions, type QueryLink, type QueryLinkOptions, type QueryLinkService, type QueryRequestV3, type QueryResultV3, type QuerySnapshot, type QuerySnapshotCache, QuerySnapshotHttpError, type QuerySnapshotHttpErrorCode, type QuerySnapshotStore, type QueryState, type RegexInspection, type RelationshipAdapter, type RepresentativeOrder, type RepresentativeRow, type ResolvedObjectReference, type RowComputedValues, type RowId, type SavedPropertyView, type SavedQuery, type SelectColumn, type SelectConfig, type ServerQuery, type ServerQueryV2, type SetFilterMetadata, type SetFilterMode, type SortConfig, type SourceDependencies, type StorageAdapter, type SummaryColumn, type SummaryOp, type Transport, type WhereClause, type WhereTerm, aggOpAllowedForType, aggOpNeedsField, aggOpsForField, applyAggregations, applyQuery, boxSummary, coerceValue, compareMetricValues, compileFormula, compileMetric, computedFieldName, createGroupingModel, createPropertyView, createQueryLinkService, createSetFilter, decodeQuery, decodeQueryStrict, discoverFieldRelationships, encodeQuery, evaluateMetricReductions, evaluateMetrics, filterValues, formulaRuntime, groupPreview, hasRegex, histogramCounts, histogramEdges, httpComputedColumnStore, httpQuerySnapshotStore, indexFields, isComputedCellError, isComputedField, isFilterable, isGroupable, isMeasurable, isNegativePredicate, isOrGroup, isPushdownFilter, isSelectable, isSortable, itemPageFields, jsonPropertyViewStorage, loadSchema, localPropertyViewStorage, localQuerySnapshotCache, localStorageAdapter, mapSetFilterValues, matchesClause, memoryComputedColumnStore, memoryPropertyViewStorage, memoryQuerySnapshotCache, memoryStorageAdapter, metricAggregatePlans, metricComputationKey, metricDateFloor, metricDateNext, metricDateRange, metricDateTime, metricDependencies, metricExpression, metricPlans, negateClause, normalizePropertyFormat, normalizePropertyView, normalizeQueryState, objectReferenceKey, opAllowedForType, opPairsForField, opsForField, parseRelativeDuration, percentile, predicatesOf, prepareGrouping, queriesEqual, readFieldValue, readObjectReference, readSetFilter, reduceMetricValues, renderItemPageTemplate, resolveFieldName, selectMetricShownRows, selectedFields, sourceDependencies, sourceExecutionSchema, stripSetFilter, toAggregationQuery, toMetricQuery, toQueryRequestV3, toServerQuery, toServerQueryV2, validateComputedColumn, validateDateGrouping, validateItemPageTemplate, validateMetric, validateQueryResultV3, validateQuerySnapshot, withoutGrouping };
+/** The query selecting the records behind one metric bucket, or null when no
+ * exact query exists.
+ *
+ * - Each `clause.groupBy` key adds `=`; a null key adds `is_null` (legacy
+ *   aggregates already place empty text in that bucket).
+ * - A date-grouped key becomes `>= start` and `< next`, using the clause's
+ *   interval and timezone.
+ * - A histogram bin (`bucket.bin`) adds `>= min` and `< max` (`<= max` for
+ *   the final bin) on the distribution input, which must be a field reference.
+ *   Box cohorts are their group keys.
+ * - The clause's own `where` is added first, so the records match the metric's
+ *   population. Groups hidden by `minCount` have no bucket to inspect.
+ * - Over a grouped query the filters are HAVING terms on the group rows.
+ * - `scope: "shownRows"`, a remainder bucket (keys that do not match the
+ *   grouping) and keys on fields that cannot be filtered return null.
+ *
+ * Existing terms are kept, duplicates are not added and the offset resets. */
+declare function inspectBucketQuery(query: QueryState, bucket: AggregationBucket, clause: AggregationClause, schema: FieldSchema): QueryState | null;
+/** The record query behind one grouped row, or null when the query is not
+ * grouped or a key cannot be matched exactly (textarray, unknown or
+ * unfilterable fields, unparseable datetimes).
+ *
+ * Starts from the grouping source, as leaving the grouping stage does, so its
+ * WHERE, columns, order and item details are kept. Each key adds `=` (or
+ * `is_null` for a null key) and the offset resets. */
+declare function groupSourceQuery(query: QueryState, group: GroupedRow, schema: FieldSchema): QueryState | null;
+
+/** Host routes for query-kind links, keyed by `LinkSpec.to.target`. Each
+ * returns an href; it is safety-checked before rendering. */
+type LinkTargets = Record<string, (query: QueryState, params: Record<string, string>) => string>;
+interface ResolvedGroupLink {
+    label: string;
+    /** Not yet safety-checked; null when the link cannot be followed. */
+    href: string | null;
+    problem?: string;
+}
+/** Link columns are computed on the client. Server requests carry only the
+ * keys and summaries they read. */
+declare function withoutLinkSummaries(summaries: readonly SummaryColumn[]): SummaryColumn[];
+/** The query a query-kind link opens, or null for template links, invalid
+ * links and ungrouped queries.
+ *
+ * Starts from `grouping.source` (or `EMPTY_QUERY` for `base: "empty"`), adds
+ * the group's key predicates unless `keyFilters` is false, resets the offset
+ * and finally applies the link's patch. With the defaults this is
+ * `groupSourceQuery` followed by the patch. */
+declare function groupLinkQuery(query: QueryState, value: GroupLinkValue): QueryState | null;
+/** Resolve a link cell to its label and href. Unregistered targets, failing
+ * routes and unresolvable values return `href: null` with a `problem`. */
+declare function resolveGroupLink(query: QueryState, value: GroupLinkValue, targets?: LinkTargets): ResolvedGroupLink;
+
+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 BackendField, COMPUTED_PREFIX, 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_LINK_RENDER, type GroupLinkValue, type GroupedRow, type GroupingDefinition, type GroupingModel, type GroupingState, type GroupingView, ITEM_DETAILS_COLUMN, type ItemDetailMode, type ItemDetailsState, type ItemPageOptions, type ItemPropertyMode, type JsonCellDisplay, type LinkDestination, type LinkSpec, type LinkTargets, MAX_AGGREGATIONS, MAX_GROUP_BY_FIELDS, 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_DATE_INTERVALS, METRIC_FUNCTIONS, type MetricAxisScale, type MetricBoxSummary, type MetricCapabilities, type MetricDateGrouping, type MetricDiagnostic, type MetricDisplay, type MetricDistribution, type MetricDistributionResult, type MetricEvaluationOptions, type MetricHistogramBin, type MetricKey, type MetricLayout, type MetricPlan, type MetricPopulationSupport, type MetricQuery, type MetricReductionOptions, type MetricScope, type MetricSort, type MetricValue, type MetricValueFormat, NULLARY_OPS, OPS_BY_TYPE, OP_LABEL, type ObjectReference, type ObjectTypeDefinition, type OpChoice, type OpPair, type OrGroup, 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 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 WhereClause, type WhereTerm, aggOpAllowedForType, aggOpNeedsField, aggOpsForField, applyAggregations, applyPatch, applyQuery, boxSummary, coerceValue, compareMetricValues, compileFormula, compileMetric, computedFieldName, createGroupingModel, createPropertyView, createQueryLinkService, createSetFilter, decodeQuery, decodeQueryStrict, discoverFieldRelationships, encodeQuery, evaluateMetricReductions, evaluateMetrics, exitGrouping, filterValues, formulaRuntime, groupLinkQuery, groupPreview, groupSourceQuery, hasRegex, histogramCounts, histogramEdges, httpComputedColumnStore, httpQuerySnapshotStore, indexFields, inspectBucketQuery, isComputedCellError, isComputedField, isFilterable, isGroupLinkField, isGroupLinkValue, isGroupable, isMeasurable, isNegativePredicate, isOrGroup, isPushdownFilter, isSelectable, isSortable, itemPageFields, jsonPropertyViewStorage, loadSchema, localPropertyViewStorage, localQuerySnapshotCache, localStorageAdapter, mapSetFilterValues, matchPatch, matchesClause, memoryComputedColumnStore, memoryPropertyViewStorage, memoryQuerySnapshotCache, memoryStorageAdapter, metricAggregatePlans, metricComputationKey, metricDateFloor, metricDateNext, metricDateRange, metricDateTime, metricDependencies, metricExpression, metricPlans, metricPopulationError, negateClause, normalizePropertyFormat, normalizePropertyView, normalizeQueryState, objectReferenceKey, opAllowedForType, opPairsForField, opsForField, parseRelativeDuration, percentile, predicatesOf, prepareGrouping, queriesEqual, readFieldValue, readObjectReference, readSetFilter, reduceMetricValues, removePatch, renderItemPageTemplate, resolveFieldName, resolveGroupLink, selectMetricShownRows, selectedFields, setFilterModes, setFilterTarget, sourceDependencies, sourceExecutionSchema, stripSetFilter, toAggregationQuery, toMetricQuery, toQueryRequestV3, toServerQuery, toServerQueryV2, validateComputedColumn, validateDateGrouping, validateItemPageTemplate, validateMetric, validateQueryResultV3, validateQuerySnapshot, withGroupingKeys, withoutGrouping, withoutLinkSummaries };