@pythia-software/query-table-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 query-table contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# @pythia-software/query-table-core
+
+Framework-agnostic query state, schema contracts, filtering, sorting,
+aggregation, serialization, and transport/storage interfaces for query-table.
+
+## Install
+
+```bash
+npm install @pythia-software/query-table-core
+```
+
+## Example
+
+```ts
+import {
+  EMPTY_QUERY,
+  loadSchema,
+  normalizeQueryState,
+  toServerQuery,
+} from "@pythia-software/query-table-core";
+
+const schema = loadSchema({
+  name: "orders",
+  idField: "id",
+  fields: [
+    {
+      name: "id",
+      label: "Order",
+      type: "number",
+      bindings: { postgres: { expr: "o.id" } },
+    },
+  ],
+});
+
+const query = normalizeQueryState({ ...EMPTY_QUERY, limit: 50 });
+const request = toServerQuery(query, schema);
+```
+
+Query state is bounded whenever it crosses the library's URL, storage, or
+server-projection boundaries. SQL expressions remain trusted server-side schema
+configuration; request values are never SQL fragments.
+
+See the [repository README](https://github.com/Pythia-Software/query-table#readme)
+for the complete schema and backend documentation.

package/dist/index.d.ts

@@ -0,0 +1,422 @@
+/** 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" | "includes" | "is_null" | "is_not_null";
+/** A single AND-combined filter. `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 runtime shape). Unused for
+ *  the nullary ops (`is_null`/`is_not_null`). */
+interface WhereClause {
+    field: string;
+    op: FilterOp;
+    value: string;
+}
+/** 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";
+}
+/** 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 {
+    field: string;
+    /** Pixel width override. Omitted = FieldDef.select.width, else the type default. */
+    width?: number;
+}
+/** 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.
+ *
+ *  Scope is deliberately the *whole filtered set* — the same WHERE as the table,
+ *  but NOT its ORDER BY / LIMIT / OFFSET. It is always evaluated on the server
+ *  (a real GROUP BY), so it reflects every matching row, not just the visible
+ *  page. Lives inside QueryState so it round-trips through `?q=`, saved queries,
+ *  and undo/redo for free — a saved query is a saved dashboard. */
+interface AggregationClause {
+    /** Stable id; keys the metric panel and survives a `?q=` round-trip. */
+    id: string;
+    op: AggOp;
+    /** Measure column (FieldDef.name). Omit only for `count` (⇒ COUNT(*)). */
+    field?: string;
+    /** Group-by columns, in axis order. `[]` = a single grand-total value.
+     *  One ⇒ a list/bar breakdown; two ⇒ an x/y pivot; three+ ⇒ a flat table. */
+    groupBy: string[];
+    /** Panel header override; defaults to a derived label like "avg total". */
+    label?: string;
+}
+interface QueryState {
+    /** Ordered SELECT list + per-column widths. Empty = the schema's default columns. */
+    select: SelectColumn[];
+    /** AND-combined filters. */
+    where: WhereClause[];
+    /** Multi-sort terms in priority order. Empty = the schema's default sort. */
+    orderBy: OrderByClause[];
+    /** Page size. */
+    limit: number;
+    /** Page offset (rows). */
+    offset: number;
+    /** Optional aggregate metrics shown above the table. Omitted/empty = none.
+     *  Each runs as its own server GROUP BY over the WHERE-filtered set (no paging). */
+    aggregations?: AggregationClause[];
+}
+/** A row's stable identity, used for selection and per-row refresh. */
+type RowId = string | number;
+/** The query a fresh table starts from before schema defaults are layered on.
+ *  Empty `select`/`orderBy`/`where` mean "defer to the schema", which also keeps
+ *  encoded `?q=` tokens short (defaults are omitted). */
+declare const EMPTY_QUERY: QueryState;
+/** Resource limits applied whenever query state crosses a trust boundary (URL,
+ * storage, an imperative setQuery call, or a server projection). They keep a
+ * malformed bookmark from becoming an unexpectedly expensive request. */
+declare const MAX_QUERY_LIMIT = 1000;
+declare const MAX_QUERY_OFFSET = 1000000;
+declare const MAX_SELECT_COLUMNS = 200;
+declare const MAX_WHERE_CLAUSES = 100;
+declare const MAX_ORDER_BY_TERMS = 20;
+declare const MAX_AGGREGATIONS = 20;
+declare const MAX_GROUP_BY_FIELDS = 20;
+declare const MAX_QUERY_TOKEN_LENGTH: number;
+/** Convert unknown input into a bounded, structurally valid QueryState.
+ * Invalid members are dropped; invalid scalar paging values use the supplied
+ * fallback. This function is intentionally schema-agnostic—field allowlisting
+ * still happens in toServerQuery and in the backend compiler. */
+declare function normalizeQueryState(input: unknown, fallback?: QueryState): QueryState;
+/** Structural equality on two queries — used to decide whether a `?q=` write or a
+ *  refetch is actually needed (avoids history spam / redundant fetches). */
+declare function queriesEqual(a: QueryState, b: QueryState): boolean;
+
+type FieldType = "text" | "number" | "enum" | "datetime" | "bool" | "textarray";
+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
+ *  reference it, but core never imports React — `unknown` stands in for the node
+ *  and @pythia-software/query-table-ui narrows it to `React.ReactNode`. */
+type CellRenderer<Row = any, V = unknown> = (ctx: {
+    value: V;
+    row: Row;
+    field: FieldDef<Row, V>;
+}) => unknown;
+/** A column the backend returns and can filter/sort. Its SQL expression lives in
+ *  the JSON schema doc's `bindings` (and the Go Schema), never on the frontend. */
+interface BackendField {
+    kind: "backend";
+    /** Dotted path into the API row when it differs from `name` (e.g. "enqueued_at.Time"). */
+    path?: string;
+    /** Computed SQL with no backing column (e.g. is_starred). Documentation hint
+     *  surfaced to the picker; the actual expression is server-side. */
+    synthetic?: boolean;
+}
+/** A value computed on the client, or a purely render-driven column. Never
+ *  pushed to the server; client-side filtering/sorting (if any) reads `accessor`. */
+interface DerivedField<Row = any, V = unknown> {
+    kind: "derived";
+    /** Compute the value from the row for client filter/sort. Omit for render-only
+     *  columns (the renderer reads the whole row from CellContext instead). */
+    accessor?: (row: Row) => V;
+}
+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
+ *  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 = {
+    source: "autocomplete";
+} | {
+    source: "static";
+    options: string[];
+} | {
+    source: "freeform";
+};
+interface FilterConfig {
+    /** Whether this field is filterable. Default: backend ⇒ true, derived ⇒ false. */
+    enabled?: boolean;
+    /** Evaluate on the backend (predicate pushdown)? Default: backend ⇒ true.
+     *  false ⇒ the clause is stripped from the server request and applied locally
+     *  by applyQuery (the "serverFilter:false" derived/JSONB-less columns). */
+    pushdown?: boolean;
+    /** Override the default operator set for the field's type. */
+    ops?: FilterOp[];
+    /** Value-suggestion strategy. Default { source: "autocomplete" }. */
+    values?: FilterValues;
+}
+interface SortConfig {
+    /** Whether this field is sortable. Default: backend ⇒ true, derived ⇒ false. */
+    enabled?: boolean;
+    /** Server field to ORDER BY when it differs from the display field
+     *  (e.g. a "★" column whose server sort key is `is_starred`). */
+    field?: string;
+}
+interface SelectConfig {
+    /** Can this appear as a visible column? Default true. false ⇒ filter-only field. */
+    enabled?: boolean;
+    /** Shown by default when QueryState.select is empty. */
+    default?: boolean;
+    /** Default column width (px); a per-column override rides in QueryState.select. */
+    width?: number;
+    align?: Align;
+}
+interface AggregateConfig {
+    /** Can this field be a metric's MEASURE (sum/avg/min/max/count_distinct)?
+     *  Default: backend ⇒ true, derived ⇒ false. */
+    measure?: boolean;
+    /** Can this field be a GROUP BY key? Default: enum/text/bool ⇒ true. */
+    groupable?: boolean;
+    /** Override the default aggregate-op set for the field's type. */
+    ops?: AggOp[];
+}
+interface FieldDef<Row = any, V = unknown> {
+    name: string;
+    label: string;
+    type: FieldType;
+    source: FieldSource<Row, V>;
+    filter?: FilterConfig;
+    sort?: SortConfig;
+    select?: SelectConfig;
+    aggregate?: AggregateConfig;
+    group?: string;
+    alias?: string;
+    aliases?: string[];
+    render?: string | CellRenderer<Row, V>;
+}
+/** The frontend's loaded schema for one dataset. */
+interface FieldSchema<Row = any> {
+    /** Dataset id, also the StorageAdapter namespace for saved queries. */
+    name: string;
+    /** Field that yields a row's stable id for selection / per-row refresh. */
+    idField: string;
+    fields: FieldDef<Row>[];
+    /** Sort applied when QueryState.orderBy is empty. */
+    defaultSort?: OrderByClause[];
+    /** Columns shown when QueryState.select is empty. */
+    defaultSelect?: SelectColumn[];
+    /** Page size for a fresh query. */
+    defaultLimit?: number;
+}
+declare function isFilterable(f: FieldDef): boolean;
+declare function isPushdownFilter(f: FieldDef): boolean;
+declare function isSortable(f: FieldDef): boolean;
+declare function isSelectable(f: FieldDef): boolean;
+declare function filterValues(f: FieldDef): FilterValues;
+/** Index fields by name for O(1) lookup. */
+declare function indexFields<Row>(schema: FieldSchema<Row>): Map<string, FieldDef<Row>>;
+/** Resolve the ordered, selectable FieldDefs for a query, falling back to schema
+ *  defaults, then to every `select.default` field. Unknown/duplicate/unselectable
+ *  names in `select` are dropped. */
+declare function selectedFields<Row>(schema: FieldSchema<Row>, q: {
+    select: SelectColumn[];
+}): FieldDef<Row>[];
+/** Read a field's value from a row: derived `accessor` if present, else the
+ *  backend `path` (dotted) / `name`. Returns null when any path segment is missing. */
+declare function readFieldValue<Row, V = unknown>(field: FieldDef<Row, V>, row: Row): V | null;
+/** Parse + validate a raw JSON schema document into a FieldSchema. The doc is the
+ *  same one the Go backend loads; here we drop backend `bindings` (the frontend
+ *  never sees SQL) and leave `render` as a string key the consumer maps to a
+ *  renderer at runtime. Throws with a readable message on a malformed document. */
+declare function loadSchema<Row = any>(doc: unknown): FieldSchema<Row>;
+
+/** Default operator set per type. A FieldDef.filter.ops overrides this. */
+declare const OPS_BY_TYPE: Record<FieldType, FilterOp[]>;
+/** Operators that take no value (the value input is hidden). */
+declare const NULLARY_OPS: ReadonlySet<FilterOp>;
+/** Effective operators for a field (its override, else the type default). */
+declare function opsForField(field: Pick<FieldDef, "type" | "filter">): FilterOp[];
+/** Whether an op is valid for a type per the default matrix (server mirror lives
+ *  in Go opAllowed; keep them in lockstep). */
+declare function opAllowedForType(type: FieldType, op: FilterOp): boolean;
+/** Coerce a raw string value to the type the field expects, for client-side
+ *  comparison. Throws on invalid input (e.g. a non-numeric value on a number
+ *  field) so callers can surface it rather than silently mis-filtering. */
+declare function coerceValue(type: FieldType, raw: string): string | number | boolean;
+
+/** Default aggregate ops per field type. A FieldDef.aggregate.ops overrides this.
+ *  `count`/`count_distinct` work on anything countable; sum/avg are numeric-only;
+ *  min/max need an ordered domain (numbers, datetimes, and lexical text/enum). */
+declare const AGG_OPS_BY_TYPE: Record<FieldType, AggOp[]>;
+/** Ops that reduce a measure column. `count` is the only op that may omit a
+ *  field (counting rows), so it's the only one absent here. */
+declare const AGG_OPS_NEEDING_FIELD: ReadonlySet<AggOp>;
+/** Whether an op requires a measure column. */
+declare function aggOpNeedsField(op: AggOp): boolean;
+/** Effective aggregate ops for a field (its override, else the type default). */
+declare function aggOpsForField(field: Pick<FieldDef, "type" | "aggregate">): AggOp[];
+/** Whether an op is valid for a type per the default matrix (Go aggOpAllowed is
+ *  the server mirror; keep them in lockstep). */
+declare function aggOpAllowedForType(type: FieldType, op: AggOp): boolean;
+/** Can this field be the MEASURE of a metric? Only backend fields (they have SQL
+ *  to aggregate); derived/render-only columns are never pushed to the server. An
+ *  explicit `aggregate.measure` wins over the type default. */
+declare function isMeasurable(field: FieldDef): boolean;
+/** Can this field be a GROUP BY key? Backend fields only. Default: low-cardinality
+ *  types (enum/text/bool); numbers/datetimes need bucketing (out of scope) so they
+ *  default off, but `aggregate.groupable: true` opts any backend field in. */
+declare function isGroupable(field: FieldDef): boolean;
+
+/** QueryState → base64url token (omitting defaults). All-default query → "". */
+declare function encodeQuery(q: QueryState): string;
+/** base64url token → QueryState. Tolerant: bad input and legacy shapes both
+ *  normalize to a valid QueryState (never throws). */
+declare function decodeQuery(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 clauses on pushdown-filterable fields. */
+    where: WhereClause[];
+    /** 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;
+}
+/** 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 {
+    where: WhereClause[];
+    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: (string | null)[];
+    /** 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: number | string | null;
+    /** 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 {
+    /** 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 ApplyResult<Row> {
+    /** The page slice (after filter + sort + offset/limit). */
+    rows: Row[];
+    /** Total matching rows *before* pagination — powers "showing N of M". */
+    total: number;
+}
+/** Filter + multi-sort + paginate `rows` per `q`, resolving field types/paths
+ *  from `schema`. Pure; never mutates `rows`. Clauses/sorts on unknown fields are
+ *  ignored (the backend already enforced its own allowlist). */
+declare function applyQuery<Row>(rows: Row[], q: QueryState, schema: FieldSchema<Row>): ApplyResult<Row>;
+/** Does one row satisfy one clause? Exposed for the CellMenu preview + tests. */
+declare function matchesClause<Row>(row: Row, clause: WhereClause, schema: FieldSchema<Row>): boolean;
+/** Client-side mirror of the backend GROUP BY (the executor for `clientRows`
+ *  mode / the demo). Scope matches the server contract: the WHERE-filtered set
+ *  only — ORDER BY / LIMIT / OFFSET are intentionally ignored, so a metric
+ *  reflects every matching row, not the visible page. Must agree with
+ *  backends/go's aggregate compile on op semantics. */
+declare function applyAggregations<Row>(rows: Row[], q: QueryState, schema: FieldSchema<Row>): AggregationResult;
+
+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;
+}
+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. */
+    hasNull?: boolean;
+}
+/** Per-field metadata for the field picker. */
+interface FieldStats {
+    distinct?: number;
+    min?: string | number;
+    max?: string | number;
+}
+interface Transport<Row = any> {
+    /** Run a server query. The only required method — a purely client-side table
+     *  can omit a Transport entirely and rely on applyQuery over local rows. */
+    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>>;
+}
+interface SavedQuery {
+    id: string;
+    name: string;
+    /** Epoch millis; injected by the caller so core stays deterministic/testable. */
+    savedAt: number;
+    query: QueryState;
+}
+/** Persistence for the "last" query (auto-restored) and named saved queries. All
+ *  methods are namespaced by `key` (the schema/dataset name) so multiple tables
+ *  on one origin don't collide. Async to allow backend implementations; the
+ *  browser adapters can still resolve synchronously. */
+interface StorageAdapter {
+    loadLast(key: string): Promise<QueryState | null>;
+    saveLast(key: string, query: QueryState): Promise<void>;
+    listSaved(key: string): Promise<SavedQuery[]>;
+    /** Load the saved query selected as the default view for this key. Optional so
+     *  existing backend adapters keep working until they add first-class support. */
+    loadDefaultSaved?(key: string): Promise<SavedQuery | null>;
+    /** Set or clear the saved query used as the default view for this key. */
+    setDefaultSaved?(key: string, id: string | null): Promise<void>;
+    /** Persist a named query snapshot. Rejects when a saved query with the same
+     *  name already exists in the key namespace. */
+    saveNamed(key: string, name: string, query: QueryState, savedAt: number): Promise<SavedQuery>;
+    deleteSaved(key: string, id: string): Promise<void>;
+}
+/** In-memory persistence used by default by the React package. It supports the
+ * full saved-query UI for the lifetime of a mounted table without writing
+ * filter values to durable browser storage. */
+declare function memoryStorageAdapter(): StorageAdapter;
+/** Opt-in StorageAdapter over window.localStorage. Query state includes raw
+ * filter values and is stored as cleartext JSON; do not use it for sensitive
+ * datasets. Falls back to no persistence when storage is unavailable. */
+declare function localStorageAdapter(): StorageAdapter;
+
+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, type CellRenderer, type DerivedField, type DistinctValuesQuery, type DistinctValuesResult, EMPTY_QUERY, type FetchRowsResult, type FieldDef, type FieldSchema, type FieldSource, type FieldStats, type FieldType, type FilterConfig, type FilterOp, type FilterValues, MAX_AGGREGATIONS, MAX_GROUP_BY_FIELDS, MAX_ORDER_BY_TERMS, MAX_QUERY_LIMIT, MAX_QUERY_OFFSET, MAX_QUERY_TOKEN_LENGTH, MAX_SELECT_COLUMNS, MAX_WHERE_CLAUSES, NULLARY_OPS, OPS_BY_TYPE, type OrderByClause, type QueryState, type RowId, type SavedQuery, type SelectColumn, type SelectConfig, type ServerQuery, type SortConfig, type StorageAdapter, type Transport, type WhereClause, aggOpAllowedForType, aggOpNeedsField, aggOpsForField, applyAggregations, applyQuery, coerceValue, decodeQuery, encodeQuery, filterValues, indexFields, isFilterable, isGroupable, isMeasurable, isPushdownFilter, isSelectable, isSortable, loadSchema, localStorageAdapter, matchesClause, memoryStorageAdapter, normalizeQueryState, opAllowedForType, opsForField, queriesEqual, readFieldValue, selectedFields, toAggregationQuery, toServerQuery };