better-supabase 0.12.0 → 0.13.0

package/dist/field-errors-CKEqR38q.d.ts

@@ -0,0 +1,119 @@
+import { b as DbError } from "./result-mijqfoJN.js";
+import { J as QuerySpec } from "./define-D0LSXmUP.js";
+import { $ as TemplateValues } from "./bucket-DBay-ICp.js";
+import { _ as TopicMessage, c as RealtimeClient, d as SubscribeOptions, i as PresenceOptions, s as PresenceSubscription } from "./topic-CZvLXFND.js";
+import { t as ClientPorts } from "./ports-n3ZWSS_I.js";
+import { a as ClientAuth } from "./bind-DcXLU1ul.js";
+import { a as LiveSource, r as LiveCountSeed } from "./index-C7-2ZS9f.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/bindings/client.d.ts
+/** The parts of `createClient()` the bindings need. */
+interface ClientLike {
+  readonly betterSupabase: LiveSource;
+  readonly supabase: SupabaseClient;
+  readonly auth: ClientAuth;
+  readonly db: object;
+  readonly queries: object;
+  /** The platform services block controllers use; see `ClientPorts`. */
+  readonly ports?: ClientPorts;
+}
+/** What a `bs.action()` Server Action or server function resolves to. */
+type ActionResultOf<T> = {
+  readonly ok: true;
+  readonly data: T;
+  readonly error: null;
+} | {
+  readonly ok: false;
+  readonly data: null;
+  readonly error: DbError;
+};
+/**
+ * The input `useAction` passes: a `bs.action()` with an `input` schema also
+ * accepts `FormData`, which belongs to `useActionForm`.
+ */
+type ActionInputOf<I> = [Exclude<I, FormData>] extends [never] ? I : Exclude<I, FormData>;
+interface UseActionOptions<I, T> {
+  readonly onSuccess?: (data: T, input: I) => void;
+  readonly onError?: (error: DbError, input: I) => void;
+}
+interface BroadcastOptions extends Omit<SubscribeOptions, "onStatus"> {
+  /**
+   * A supabase-js client to subscribe with, for apps without the provider. It
+   * resubscribes when the client's user changes. Defaults to the provider's
+   * client.
+   */
+  readonly client?: SupabaseClient;
+  /** The query client `invalidate` refetches with. Defaults to the provider's. */
+  readonly queryClient?: QueryClient;
+  /**
+   * Refetch after each message: table keys (every query that read one of them),
+   * or a function returning query keys. Needs a `queryClient`, here or on the
+   * provider.
+   */
+  readonly invalidate?: readonly string[] | ((message: TopicMessage) => readonly (readonly unknown[])[]);
+}
+interface LiveQueryHookOptions {
+  /**
+   * Tenant for tenant-scoped tables. Defaults to the `config.claims.tenant`
+   * claim (`tenant_id`, top-level or in `app_metadata`).
+   */
+  readonly tenant?: string;
+  /** Defaults to 100 ms. */
+  readonly debounceMs?: number;
+}
+interface LiveCountHookOptions extends LiveQueryHookOptions {
+  /** The count to show before the first fetch, e.g. from the server. */
+  readonly initial?: number;
+}
+interface PresenceHookOptions<I> {
+  /**
+   * The state this client shares while joined. It is tracked after the join and
+   * tracked again when its JSON changes; `null` stays untracked.
+   */
+  readonly state?: I | null;
+  /** A supabase-js client for apps without the provider. */
+  readonly client?: SupabaseClient;
+}
+/** The parts of a `defineTopic(..., { presence })` topic the bindings use. */
+interface PresenceTopic<P extends string, I, O> {
+  topic(values: TemplateValues<P>): string;
+  match(topic: string): TemplateValues<P> | null;
+  subscribe(client: RealtimeClient, values: TemplateValues<P>, handlers: Readonly<Record<string, never>>, options?: SubscribeOptions & PresenceOptions<O>): PresenceSubscription<I, O>;
+}
+/** Who a subscription runs as. */
+/**
+ * The claims type of a client's `betterSupabase.claims(schema)`, `unknown`
+ * without one.
+ */
+type ClaimsOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly claimsSchema: StandardSchemaV1<unknown, infer C> | undefined;
+} ? C : unknown;
+/**
+ * The profile type of a client's `betterSupabase.userMetadata(schema)`,
+ * `unknown` without one.
+ */
+type ProfileOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly userMetadataSchema: StandardSchemaV1<unknown, infer P> | undefined;
+} ? P : unknown;
+/** A count spec or a `bs.liveCount()` seed. */
+type LiveCountSource = QuerySpec<string, "count", number> | LiveCountSeed | null | undefined;
+interface ActionState<I, T> {
+  /** True while a run is in flight. */
+  readonly pending: boolean;
+  /** The inputs of the runs in flight, e.g. to dim one table row. */
+  readonly pendingInputs: readonly I[];
+  /** The input of the latest run in flight. */
+  readonly pendingInput: I | undefined;
+  /** The data of the last successful run. */
+  readonly data: T | undefined;
+  /** The error of the last run, until the next one starts. */
+  readonly error: DbError | undefined;
+}
+//#endregion
+//#region src/bindings/field-errors.d.ts
+/** The first message per top-level field of a `validation` error. */
+declare function fieldErrorsOf(error: DbError | undefined): Readonly<Partial<Record<string, string>>>;
+//#endregion
+export { BroadcastOptions as a, LiveCountHookOptions as c, PresenceHookOptions as d, PresenceTopic as f, ActionState as i, LiveCountSource as l, UseActionOptions as m, ActionInputOf as n, ClaimsOf as o, ProfileOf as p, ActionResultOf as r, ClientLike as s, fieldErrorsOf as t, LiveQueryHookOptions as u };

package/dist/field-formats-BX2FqLle.d.ts

@@ -0,0 +1,39 @@
+import { s as FormFieldType } from "./form-definition-DcVnFzl4.js";
+//#region src/core/contracts/field-formats.d.ts
+/**
+ * The one field vocabulary: the formats an app table column takes and the types
+ * a custom field takes. App tables render each format's check from here,
+ * `scaffold screens` picks the input, and the forms block answers a custom
+ * field with the form field type it maps to.
+ */
+/** The Postgres column types a format fits. */
+type FieldFormatColumnType = "text" | "integer" | "bigint" | "numeric";
+/** The HTML input a format edits with. */
+type FieldFormatInput = "email" | "url" | "tel" | "textarea" | "color" | "number";
+interface FieldFormat {
+  readonly types: readonly FieldFormatColumnType[];
+  /** A POSIX regular expression the value matches, ignoring case. */
+  readonly pattern?: string;
+  /** The bounds when the column sets no `min` or `max`. */
+  readonly bounds?: readonly [min: number, max: number];
+  readonly input: FieldFormatInput;
+  /** The forms block field type that collects the value. */
+  readonly formType: FormFieldType;
+}
+declare const FIELD_FORMAT_NAMES: readonly ["email", "url", "phone", "long_text", "color", "rating", "percent", "currency"];
+type FieldFormatName = (typeof FIELD_FORMAT_NAMES)[number];
+/**
+ * Money is a `currency` `bigint` of minor units next to a `text` column of 3
+ * characters for the code (ADR 0037).
+ */
+declare const FIELD_FORMATS: Readonly<Record<FieldFormatName, FieldFormat>>;
+/**
+ * The types of a custom field definition. A value is stored as text either way;
+ * the type tells the form and the UI what it holds. `user` holds a user id,
+ * `currency` an integer of minor units, and `multi_option` a JSON array of
+ * option values.
+ */
+declare const CUSTOM_FIELD_TYPES: readonly ["text", "number", "date", "bool", "option", "json", "email", "url", "multi_option", "user", "rating", "currency"];
+type CustomFieldType = (typeof CUSTOM_FIELD_TYPES)[number];
+//#endregion
+export { FieldFormat as a, FIELD_FORMAT_NAMES as i, CustomFieldType as n, FieldFormatInput as o, FIELD_FORMATS as r, FieldFormatName as s, CUSTOM_FIELD_TYPES as t };

package/dist/field-formats-C6QKA3UR.js

@@ -0,0 +1,102 @@
+//#region src/core/contracts/field-formats.ts
+const FIELD_FORMAT_NAMES = [
+	"email",
+	"url",
+	"phone",
+	"long_text",
+	"color",
+	"rating",
+	"percent",
+	"currency"
+];
+/** The stars a `rating` takes, for a column and for a custom field. */
+const RATING_BOUNDS = [1, 5];
+const EMAIL = String.raw`^[^@\s]+@[^@\s]+\.[^@\s]+$`;
+const URL = String.raw`^https?://\S+$`;
+/**
+* Money is a `currency` `bigint` of minor units next to a `text` column of 3
+* characters for the code (ADR 0037).
+*/
+const FIELD_FORMATS = {
+	email: {
+		types: ["text"],
+		pattern: EMAIL,
+		input: "email",
+		formType: "email"
+	},
+	url: {
+		types: ["text"],
+		pattern: URL,
+		input: "url",
+		formType: "url"
+	},
+	phone: {
+		types: ["text"],
+		input: "tel",
+		formType: "text"
+	},
+	long_text: {
+		types: ["text"],
+		input: "textarea",
+		formType: "textarea"
+	},
+	color: {
+		types: ["text"],
+		input: "color",
+		formType: "text"
+	},
+	rating: {
+		types: ["integer", "bigint"],
+		bounds: RATING_BOUNDS,
+		input: "number",
+		formType: "integer"
+	},
+	percent: {
+		types: ["integer", "numeric"],
+		bounds: [0, 100],
+		input: "number",
+		formType: "number"
+	},
+	currency: {
+		types: ["bigint"],
+		input: "number",
+		formType: "integer"
+	}
+};
+/**
+* The types of a custom field definition. A value is stored as text either way;
+* the type tells the form and the UI what it holds. `user` holds a user id,
+* `currency` an integer of minor units, and `multi_option` a JSON array of
+* option values.
+*/
+const CUSTOM_FIELD_TYPES = [
+	"text",
+	"number",
+	"date",
+	"bool",
+	"option",
+	"json",
+	"email",
+	"url",
+	"multi_option",
+	"user",
+	"rating",
+	"currency"
+];
+/** The forms block field type that answers each custom field type. */
+const CUSTOM_FIELD_FORM_TYPES = {
+	text: "text",
+	number: "number",
+	date: "date",
+	bool: "bool",
+	option: "option",
+	json: "json",
+	email: FIELD_FORMATS.email.formType,
+	url: FIELD_FORMATS.url.formType,
+	multi_option: "multi",
+	user: "text",
+	rating: FIELD_FORMATS.rating.formType,
+	currency: FIELD_FORMATS.currency.formType
+};
+//#endregion
+export { RATING_BOUNDS as a, FIELD_FORMAT_NAMES as i, CUSTOM_FIELD_TYPES as n, FIELD_FORMATS as r, CUSTOM_FIELD_FORM_TYPES as t };

package/dist/filter-evaluate-CRDXv0Dl.js

@@ -0,0 +1,217 @@
+import { c as optionalTemporal, t as TEMPORAL_MISSING } from "./temporal-DLZlWbOi.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { a as dateBounds, r as NEGATIVE } from "./filter-query-D4ZSwbcJ.js";
+//#region src/list/filter-evaluate.ts
+function read(record, column) {
+	let value = record;
+	for (const key of column.split(".")) {
+		if (!isRecord(value)) return;
+		value = value[key];
+	}
+	return value;
+}
+const missing = (value) => value === null || value === void 0;
+function numberOf(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "bigint") return Number(value);
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+}
+function textOf(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
+	return null;
+}
+function booleanOf(value) {
+	if (typeof value === "boolean") return value;
+	if (value === "true" || value === "false") return value === "true";
+	return null;
+}
+/** A value and a bound in one ordering: epoch milliseconds or ISO text. */
+function dateKey(kind, value) {
+	if (kind === "timestamptz") {
+		if (value instanceof Date) return value.getTime();
+		const T = optionalTemporal();
+		if (T !== void 0 && value instanceof T.Instant) return value.epochMilliseconds;
+		if (typeof value === "string") {
+			const ms = Date.parse(value);
+			return Number.isNaN(ms) ? null : ms;
+		}
+		return null;
+	}
+	const text = value instanceof Date ? value.toISOString().replace(/Z$/, "") : typeof value === "string" ? value : isRecord(value) && typeof value.toString === "function" ? String(value) : null;
+	if (text === null) return null;
+	if (kind === "date") return text.slice(0, 10);
+	const T = optionalTemporal();
+	if (T === void 0) throw new TypeError(TEMPORAL_MISSING);
+	try {
+		return T.PlainDateTime.from(text.replace(" ", "T")).toString({ fractionalSecondDigits: 9 });
+	} catch {
+		return null;
+	}
+}
+function boundKey(kind, bound) {
+	if (kind === "timestamptz") return Date.parse(bound);
+	return dateKey(kind, bound) ?? bound;
+}
+function dateTruth(field, operator, operand, value, clock) {
+	const kind = field.columnMeta.type;
+	const at = dateKey(kind, value);
+	if (at === null) return null;
+	if (operator === "between") {
+		const [from, to] = operand;
+		return at >= boundKey(kind, dateBounds(field, from, clock).start) && at < boundKey(kind, dateBounds(field, to, clock).end);
+	}
+	const bounds = dateBounds(field, operand, clock);
+	const start = boundKey(kind, bounds.start);
+	const end = boundKey(kind, bounds.end);
+	switch (operator) {
+		case "is": return at >= start && at < end;
+		case "is_before": return at < start;
+		case "is_after": return at >= end;
+		case "is_on_or_before": return at < end;
+		case "is_on_or_after": return at >= start;
+		default: throw new TypeError(`Unknown date operator "${operator}"`);
+	}
+}
+function equalTo(field, operand, value) {
+	if (missing(value)) return null;
+	switch (field.type) {
+		case "boolean": {
+			const actual = booleanOf(value);
+			return actual === null ? null : actual === (operand === true || operand === "true");
+		}
+		case "number": {
+			const actual = numberOf(value);
+			return actual === null ? null : actual === numberOf(operand);
+		}
+		case "text":
+		case "select":
+		case "relation":
+		case "multiselect":
+		case "date": {
+			const actual = textOf(value);
+			return actual === null ? null : actual === textOf(operand);
+		}
+		default: {
+			const never = field.type;
+			throw new TypeError(`Unknown field type ${String(never)}`);
+		}
+	}
+}
+function compare(operator, operand, value) {
+	const actual = numberOf(value);
+	const bound = numberOf(operand);
+	if (actual === null || bound === null) return null;
+	switch (operator) {
+		case "gt": return actual > bound;
+		case "gte": return actual >= bound;
+		case "lt": return actual < bound;
+		case "lte": return actual <= bound;
+		default: throw new TypeError(`Unknown operator ${String(operator)}`);
+	}
+}
+function listOf(value) {
+	if (typeof value === "string" && value.startsWith("[")) try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.map(String) : null;
+	} catch {
+		return null;
+	}
+	return Array.isArray(value) ? value.map(String) : null;
+}
+/**
+* The truth of an operator before negation, mirroring `filterWhere`'s
+* predicates.
+*/
+function positive(field, operator, operand, value, clock) {
+	switch (operator) {
+		case "empty": return field.type === "text" ? missing(value) || value === "" : missing(value);
+		case "contains":
+		case "starts_with":
+		case "ends_with": {
+			const actual = textOf(value);
+			if (actual === null) return null;
+			const haystack = actual.toLowerCase();
+			const needle = String(operand).toLowerCase();
+			return operator === "contains" ? haystack.includes(needle) : operator === "starts_with" ? haystack.startsWith(needle) : haystack.endsWith(needle);
+		}
+		case "eq": return equalTo(field, operand, value);
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte": return compare(operator, operand, value);
+		case "is_any_of": {
+			if (missing(value)) return null;
+			const actual = textOf(value);
+			return actual !== null && Array.isArray(operand) && operand.some((entry) => textOf(entry) === actual);
+		}
+		case "has_any_of":
+		case "has_all_of": {
+			const actual = listOf(value);
+			if (actual === null || !Array.isArray(operand)) return null;
+			const wanted = operand.map(String);
+			return operator === "has_any_of" ? wanted.some((entry) => actual.includes(entry)) : wanted.every((entry) => actual.includes(entry));
+		}
+		case "is": return field.type === "date" ? dateTruth(field, operator, operand, value, clock) : equalTo(field, operand, value);
+		case "between": {
+			if (field.type === "date") return dateTruth(field, operator, operand, value, clock);
+			const [from, to] = operand;
+			const low = compare("gte", Math.min(from, to), value);
+			const high = compare("lte", Math.max(from, to), value);
+			return low === null || high === null ? null : low && high;
+		}
+		default: return dateTruth(field, operator, operand, value, clock);
+	}
+}
+const not = (truth) => truth === null ? null : !truth;
+function ruleTruth(field, rule, record, clock) {
+	const value = read(record, field.column);
+	const base = NEGATIVE[rule.operator];
+	const operator = base ?? rule.operator;
+	const negative = base !== void 0 !== (rule.negated === true);
+	const truth = positive(field, operator, rule.value, value, clock);
+	if (!negative) return truth;
+	if (field.columnMeta.nullable && operator !== "empty" && missing(value)) return true;
+	return not(truth);
+}
+function combine(combinator, parts) {
+	if (combinator === "and") return parts.includes(false) ? false : parts.includes(null) ? null : true;
+	return parts.includes(true) ? true : parts.includes(null) ? null : false;
+}
+/**
+* Tests a checked filter tree on one record, with the same operators and null
+* handling as `filterWhere` compiles to SQL. Unfinished rules, unknown fields
+* and empty groups take no part, and a tree with nothing left matches.
+*/
+function evaluateFilterQuery(query, record, fields, clock = {}) {
+	const byId = new Map(fields.map((field) => [field.id, field]));
+	const results = {};
+	const visit = (node) => {
+		if (node.type === "rule") {
+			const field = byId.get(node.path.join("."));
+			if (node.operator === "" || !field) return;
+			const truth = ruleTruth(field, node, record, clock);
+			results[node.id] = truth;
+			return truth;
+		}
+		const parts = node.rules.flatMap((child) => {
+			const truth = visit(child);
+			return truth === void 0 ? [] : [truth];
+		});
+		if (parts.length === 0) return;
+		const truth = combine(node.combinator, parts);
+		results[node.id] = truth;
+		return truth;
+	};
+	const root = visit(query);
+	return {
+		matched: root === void 0 || root === true,
+		results
+	};
+}
+//#endregion
+export { evaluateFilterQuery as t };

package/dist/filter-evaluate-CSWhzYWN.d.ts

@@ -0,0 +1,37 @@
+import { h as FilterQuery, l as FilterFieldType, r as FilterClock } from "./filter-query-C7qgRYYv.js";
+//#region src/list/filter-evaluate.d.ts
+/**
+ * A field a filter tree can test on a plain record. `FilterFieldInfo` from a
+ * list definition fits; the rules block builds these from its field catalog.
+ */
+interface FilterRecordField {
+  readonly id: string;
+  readonly type: FilterFieldType;
+  /** The record key the value is read from, dotted for a nested value. */
+  readonly column: string;
+  readonly columnMeta: {
+    /**
+     * The Postgres type: `date`, `timestamp` and `timestamptz` pick how dates
+     * compare.
+     */
+    readonly type: string;
+    readonly nullable: boolean;
+  };
+}
+/**
+ * The outcome of a tree on one record. `results` holds every rule and group
+ * that took part, by node id: `null` when a comparison met a missing value,
+ * which SQL treats as unknown and a match treats as false.
+ */
+interface FilterEvaluation {
+  readonly matched: boolean;
+  readonly results: Readonly<Record<string, boolean | null>>;
+}
+/**
+ * Tests a checked filter tree on one record, with the same operators and null
+ * handling as `filterWhere` compiles to SQL. Unfinished rules, unknown fields
+ * and empty groups take no part, and a tree with nothing left matches.
+ */
+declare function evaluateFilterQuery(query: FilterQuery, record: unknown, fields: readonly FilterRecordField[], clock?: FilterClock): FilterEvaluation;
+//#endregion
+export { FilterRecordField as n, evaluateFilterQuery as r, FilterEvaluation as t };

package/dist/filter-query-C7qgRYYv.d.ts

@@ -0,0 +1,133 @@
+/// <reference lib="esnext.temporal" />
+import { f as ColumnMeta } from "./types-DmshMaXz.js";
+//#region src/list/filter-query.d.ts
+type FilterCombinator = "and" | "or";
+interface FilterRule<V = unknown> {
+  readonly id: string;
+  readonly type: "rule";
+  readonly path: readonly string[];
+  readonly operator: string;
+  readonly value?: V | undefined;
+  readonly negated?: boolean;
+}
+interface FilterGroupNode<V = unknown> {
+  readonly id: string;
+  readonly type: "group";
+  readonly combinator: FilterCombinator;
+  readonly rules: readonly FilterNode<V>[];
+}
+type FilterNode<V = unknown> = FilterRule<V> | FilterGroupNode<V>;
+type FilterQuery<V = unknown> = FilterGroupNode<V>;
+/** A calendar offset from today, resolved when the query runs. */
+interface FilterRelativeDate {
+  readonly unit: "day" | "week" | "month" | "year";
+  readonly offset: number;
+}
+/**
+ * A date value: an absolute `yyyy-MM-dd` day or a relative token, with an
+ * optional `HH:mm`.
+ */
+interface FilterDateValue {
+  readonly date?: string;
+  readonly relative?: FilterRelativeDate;
+  readonly time?: string;
+}
+type FilterOperatorArity = "none" | "one" | "many" | "range";
+/**
+ * The value types a list filter field takes. `date` and `relation` map onto
+ * ReUI editors.
+ */
+type FilterFieldType = "text" | "number" | "date" | "select" | "multiselect" | "boolean" | "relation";
+interface FilterOperatorSpec {
+  readonly value: string;
+  readonly arity: FilterOperatorArity;
+  readonly inverse?: string;
+}
+/** The operators each field type allows, in the order ReUI lists them. */
+declare const FILTER_OPERATORS: Readonly<Record<FilterFieldType, readonly FilterOperatorSpec[]>>;
+/** English operator labels, the defaults `filterFields` uses. */
+declare const FILTER_OPERATOR_LABELS: Readonly<Record<string, string>>;
+/** One entry of `defineListQuery`'s `filters`: a field the tree may name. */
+interface ListFilterConfig<C extends string = string> {
+  readonly type: FilterFieldType;
+  /** The column the field filters; defaults to the field id. */
+  readonly column?: C;
+  readonly label?: string;
+  readonly description?: string;
+  /** A subset of the type's operators. */
+  readonly operators?: readonly string[];
+  readonly defaultOperator?: string;
+  /**
+   * Allowed values for `select` and `multiselect`; defaults to the column's
+   * enum.
+   */
+  readonly options?: readonly (string | {
+    readonly value: string;
+    readonly label?: string;
+  })[];
+}
+/** A checked filter field. */
+interface FilterFieldInfo {
+  readonly id: string;
+  readonly type: FilterFieldType;
+  /** Model key of the column. */
+  readonly column: string;
+  readonly columnMeta: ColumnMeta;
+  readonly label: string;
+  readonly description?: string;
+  readonly operators: readonly FilterOperatorSpec[];
+  readonly defaultOperator?: string;
+  readonly options?: readonly {
+    readonly value: string;
+    readonly label: string;
+  }[];
+}
+interface FilterLimits {
+  readonly maxDepth: number;
+  readonly maxRules: number;
+  readonly maxValueLength: number;
+  readonly maxValues: number;
+}
+interface FilterClock {
+  /** IANA time zone dates resolve in. Defaults to `UTC`. */
+  readonly timeZone?: string;
+  /** The current instant; defaults to `Temporal.Now`. */
+  readonly now?: Temporal.Instant;
+}
+/** The structural `FilterField` objects ReUI Filters takes. */
+interface FilterField {
+  readonly id: string;
+  readonly label: string;
+  readonly description?: string;
+  readonly type?: "text" | "number" | "select" | "multiselect" | "boolean";
+  readonly options?: readonly {
+    readonly value: string;
+    readonly label: string;
+  }[];
+  readonly operators?: readonly {
+    readonly value: string;
+    readonly label: string;
+    readonly arity: FilterOperatorArity;
+    readonly inverse?: string;
+  }[];
+  readonly defaultOperator?: string;
+  /** The column the field filters. */
+  readonly column: string;
+}
+interface FilterFieldLabels {
+  /** Field labels by field id. */
+  readonly fields?: Readonly<Record<string, string>>;
+  /** Operator labels by operator value. */
+  readonly operators?: Readonly<Record<string, string>>;
+  /** Option labels by field id, then by option value. */
+  readonly options?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+}
+/** `base64url` of the tree's JSON, for one URL parameter. */
+declare function encodeFilterQuery(query: FilterQuery): string;
+/**
+ * The JSON a `filter` URL parameter holds, or `undefined` when it is not
+ * base64url JSON.
+ */
+declare function decodeFilterQuery(encoded: string): unknown;
+//#endregion
+export { FilterRule as _, FilterDateValue as a, encodeFilterQuery as b, FilterFieldLabels as c, FilterLimits as d, FilterNode as f, FilterRelativeDate as g, FilterQuery as h, FilterCombinator as i, FilterFieldType as l, FilterOperatorSpec as m, FILTER_OPERATOR_LABELS as n, FilterField as o, FilterOperatorArity as p, FilterClock as r, FilterFieldInfo as s, FILTER_OPERATORS as t, FilterGroupNode as u, ListFilterConfig as v, decodeFilterQuery as y };