better-supabase 0.7.1 → 0.9.0

package/dist/knowledge-BXBbT0Tr.d.ts

@@ -1,176 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { t as AsyncResult, w as ErrorMapper } from "./result-D7y2fT87.js";
-import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
-import { r as BlockTemporalOptions } from "./block-helpers-CKtbFcRv.js";
-import { f as AiFiles, o as AiFile } from "./types-C05bxW-W.js";
-import { m as JobHandler } from "./queue-CLJurhdy.js";
-//#region src/blocks/knowledge/knowledge.d.ts
-/**
- * Turns texts into vectors. `model` is stored with each document, so a
- * document embedded by another model can be found and embedded again.
- */
-interface Embedder {
-  /** The embedder contract version. Omitted means 1. */
-  readonly apiVersion?: 1;
-  readonly model: string;
-  embed(values: readonly string[], options?: {
-    readonly signal?: AbortSignal;
-  }): Promise<readonly (readonly number[])[]>;
-}
-type KnowledgeScope = "organization" | "agent" | "project" | "chat" | "user";
-type KnowledgeStatus = "pending" | "ready" | "failed";
-interface KnowledgeDocument {
-  readonly id: string;
-  readonly organizationId: string;
-  readonly ownerId: string;
-  readonly scope: KnowledgeScope;
-  /** The agent, project, chat or user the document belongs to; none for organization scope. */
-  readonly scopeId: string | undefined;
-  readonly fileId: string | undefined;
-  readonly title: string;
-  readonly source: string | undefined;
-  readonly metadata: Readonly<Record<string, unknown>>;
-  readonly status: KnowledgeStatus;
-  readonly error: string | undefined;
-  readonly chunkCount: number;
-  readonly embeddingModel: string | undefined;
-  readonly createdAt: Temporal.Instant;
-  readonly updatedAt: Temporal.Instant;
-}
-interface NewKnowledgeDocument {
-  readonly title: string;
-  /** Default `user`, scoped to the caller. */
-  readonly scope?: KnowledgeScope;
-  readonly scopeId?: string;
-  readonly fileId?: string;
-  /** Where the text came from: a URL, a file name or a table. */
-  readonly source?: string;
-  readonly metadata?: Readonly<Record<string, unknown>>;
-  /** The service role only: the user the document belongs to. */
-  readonly ownerId?: string;
-}
-interface KnowledgeChunk {
-  readonly content: string;
-  /** An estimate of the tokens in `content`. */
-  readonly tokens?: number;
-  readonly metadata?: Readonly<Record<string, unknown>>;
-}
-interface KnowledgeHit {
-  readonly documentId: string;
-  readonly index: number;
-  readonly content: string;
-  readonly metadata: Readonly<Record<string, unknown>>;
-  readonly title: string;
-  /** The fused reciprocal rank score; higher is better. */
-  readonly score: number;
-}
-interface KnowledgeQuery {
-  /** Searched as full text, and embedded when the block has an embedder. */
-  readonly text?: string;
-  /** An embedding of the query, used instead of embedding `text`. */
-  readonly embedding?: readonly number[];
-}
-interface KnowledgeSearchOptions {
-  /** The scopes to search, each with an optional id; every scope when unset. */
-  readonly scopes?: readonly {
-    readonly scope: KnowledgeScope;
-    readonly id?: string;
-  }[];
-  /** How many chunks to return. Default 8, at most 100. */
-  readonly k?: number;
-  /** Matches documents whose metadata contains this object. */
-  readonly filter?: Readonly<Record<string, unknown>>;
-  readonly signal?: AbortSignal;
-}
-interface ChunkOptions {
-  /** The most characters in a chunk. Default 2000. */
-  readonly size?: number;
-  /** Characters repeated from the end of the previous chunk. Default 200, or a tenth of a smaller `size`. */
-  readonly overlap?: number;
-}
-interface KnowledgeOptions extends BlockTemporalOptions {
-  /** Calls as the user: `rpcTransport(supabase)`. */
-  readonly transport: BlockTransport;
-  /** Calls as the service role, for `process`, `drain` and `reembed`. */
-  readonly service?: BlockTransport;
-  /** The module schema (`sql.modules.knowledge.schema`), default `better_supabase`. */
-  readonly schema?: string;
-  readonly mappers?: readonly ErrorMapper[];
-  /** Embeds chunks and queries; without one, search is full text only. */
-  readonly embedder?: Embedder;
-  /** The ai-files block, for `ingest.file`. */
-  readonly files?: AiFiles;
-  /**
-   * The text of a file. The default decodes `text/*`, JSON, XML and YAML
-   * as UTF-8 and fails with `KNOWLEDGE_UNSUPPORTED` for anything else.
-   */
-  readonly extract?: (file: AiFile, data: Uint8Array) => Promise<string>;
-  readonly chunking?: ChunkOptions;
-  /** Chunks per embedding call. Default 64. */
-  readonly batchSize?: number;
-}
-interface Knowledge {
-  readonly documents: {
-    create(organizationId: string, document: NewKnowledgeDocument): AsyncResult<KnowledgeDocument>;
-    get(documentId: string): AsyncResult<KnowledgeDocument>;
-    list(organizationId: string, options?: {
-      readonly scope?: KnowledgeScope;
-      readonly scopeId?: string;
-      readonly limit?: number;
-    }): AsyncResult<readonly KnowledgeDocument[]>;
-    /** Replaces the chunks; unchanged chunks keep their embedding. */
-    write(documentId: string, chunks: readonly KnowledgeChunk[]): AsyncResult<KnowledgeDocument>;
-    remove(documentId: string): AsyncResult<boolean>;
-  };
-  readonly ingest: {
-    /** Creates a document from text and writes its chunks. */
-    text(organizationId: string, document: NewKnowledgeDocument & {
-      readonly text: string;
-    }): AsyncResult<KnowledgeDocument>;
-    /** Creates a document from a ready ai-files file and writes its chunks. */
-    file(organizationId: string, fileId: string, document?: Partial<NewKnowledgeDocument>): AsyncResult<KnowledgeDocument>;
-  };
-  /**
-   * Embeds a document's pending chunks (service role). Returns how many
-   * still wait, 0 once the document is ready.
-   */
-  process(documentId: string, options?: {
-    readonly signal?: AbortSignal | undefined;
-  }): AsyncResult<number>;
-  /**
-   * The handler for the `knowledge_embed` queue. The last attempt marks
-   * the document failed with the error.
-   */
-  embedJob(): JobHandler<{
-    readonly document_id: string;
-  }>;
-  /**
-   * Processes pending documents without a queue (service role). Returns how
-   * many. A document is marked failed only after `attempts` (default 3)
-   * tries fail, and never when the signal aborted it.
-   */
-  drain(options?: {
-    readonly batch?: number;
-    readonly attempts?: number;
-    readonly signal?: AbortSignal;
-  }): AsyncResult<number>;
-  search(organizationId: string, query: string | KnowledgeQuery, options?: KnowledgeSearchOptions): AsyncResult<readonly KnowledgeHit[]>;
-  /**
-   * Marks documents embedded by another model (or every document when
-   * `model` is unset) pending again (service role). Returns how many.
-   */
-  reembed(options?: {
-    readonly organizationId?: string;
-    readonly model?: string;
-  }): AsyncResult<number>;
-}
-/**
- * Splits text into chunks of at most `size` characters, preferring a
- * paragraph, line, sentence or word break in the second half of each
- * chunk, and repeating `overlap` characters of the previous one.
- */
-declare function chunk(text: string, options?: ChunkOptions): readonly KnowledgeChunk[];
-/** Documents, chunks and hybrid search for retrieval. */
-declare function createKnowledge(options: KnowledgeOptions): Knowledge;
-//#endregion
-export { KnowledgeDocument as a, KnowledgeQuery as c, KnowledgeStatus as d, NewKnowledgeDocument as f, KnowledgeChunk as i, KnowledgeScope as l, createKnowledge as m, Embedder as n, KnowledgeHit as o, chunk as p, Knowledge as r, KnowledgeOptions as s, ChunkOptions as t, KnowledgeSearchOptions as u };

package/dist/knowledge-CDmiMLew.js

@@ -1,255 +0,0 @@
-import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { n as dbError } from "./errors-B11Duf73.js";
-import { a as ok, r as err, t as AsyncResult } from "./result-DzUbqgdW.js";
-import { t as vectorLiteral } from "./search-CUWCRYKL.js";
-import { C as run, O as textOf, b as recordOrEmpty, c as errorText, d as isRecord, h as optionalText, i as blockCall, k as toInstant, l as injectableOf, n as applyTemporal, x as recordsOf, y as recordOf } from "./block-helpers-DWHxHsEQ.js";
-//#region src/blocks/knowledge/knowledge.ts
-const SCOPES = /* @__PURE__ */ new Set([
-	"organization",
-	"agent",
-	"project",
-	"chat",
-	"user"
-]);
-const STATUSES = /* @__PURE__ */ new Set([
-	"pending",
-	"ready",
-	"failed"
-]);
-const BREAKS = [
-	"\n\n",
-	"\n",
-	". ",
-	" "
-];
-const TEXT_TYPES = /^(text\/|application\/(json|xml|yaml|x-yaml|ld\+json|x-ndjson)\b)/;
-/**
-* Splits text into chunks of at most `size` characters, preferring a
-* paragraph, line, sentence or word break in the second half of each
-* chunk, and repeating `overlap` characters of the previous one.
-*/
-function chunk(text, options = {}) {
-	const size = options.size ?? 2e3;
-	const overlap = options.overlap ?? Math.min(200, Math.floor(size / 10));
-	if (!Number.isInteger(size) || size < 1) throw new RangeError("chunk size must be a positive whole number");
-	if (!Number.isInteger(overlap) || overlap < 0 || overlap >= size) throw new RangeError("chunk overlap must be at least 0 and below size");
-	const clean = text.replaceAll(/\r\n?/g, "\n").trim();
-	const chunks = [];
-	let start = 0;
-	while (start < clean.length) {
-		let end = Math.min(start + size, clean.length);
-		if (end < clean.length) {
-			const window = clean.slice(start, end);
-			for (const mark of BREAKS) {
-				const at = window.lastIndexOf(mark);
-				if (at >= window.length / 2) {
-					end = start + at + mark.length;
-					break;
-				}
-			}
-		}
-		const content = clean.slice(start, end).trim();
-		if (content !== "") chunks.push({
-			content,
-			tokens: Math.ceil(content.length / 4)
-		});
-		if (end >= clean.length) break;
-		const back = Math.max(end - overlap, start + 1);
-		const word = /\s/.test(clean.charAt(back - 1)) ? back - 1 : clean.indexOf(" ", back);
-		start = overlap > 0 && word >= back - 1 && word < end ? word + 1 : back;
-	}
-	return chunks;
-}
-/**
-* An `invalid_input` error unless the embedder returned `count` vectors of
-* one non-zero length with finite numbers.
-*/
-function checkVectors(vectors, count) {
-	const invalid = (message) => dbError("invalid_input", message, { hint: "EMBEDDING_INVALID" });
-	if (vectors.length !== count) return invalid(`The embedder returned ${vectors.length} vectors for ${count} values`);
-	const size = vectors[0]?.length ?? 0;
-	for (const vector of vectors) {
-		if (vector.length === 0 || vector.length !== size) return invalid("The embedder returned vectors of different or zero length");
-		if (!vector.every(Number.isFinite)) return invalid("The embedder returned a vector with a non-finite number");
-	}
-}
-const scopeOf = (value) => {
-	const text = textOf(value);
-	return SCOPES.has(text) ? text : "user";
-};
-const statusOf = (value) => {
-	const text = textOf(value);
-	return STATUSES.has(text) ? text : "failed";
-};
-const instant = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
-function documentOf(value) {
-	const row = recordOf(value, "knowledge_documents");
-	return {
-		id: textOf(row["id"]),
-		organizationId: textOf(row["organization_id"]),
-		ownerId: textOf(row["owner_id"]),
-		scope: scopeOf(row["scope"]),
-		scopeId: optionalText(row["scope_id"]),
-		fileId: optionalText(row["file_id"]),
-		title: textOf(row["title"]),
-		source: optionalText(row["source"]),
-		metadata: recordOrEmpty(row["metadata"]),
-		status: statusOf(row["status"]),
-		error: optionalText(row["error"]),
-		chunkCount: Number(row["chunk_count"] ?? 0),
-		embeddingModel: optionalText(row["embedding_model"]),
-		createdAt: instant(row["created_at"]),
-		updatedAt: instant(row["updated_at"])
-	};
-}
-function hitOf(value) {
-	const row = recordOf(value, "knowledge_search");
-	return {
-		documentId: textOf(row["document_id"]),
-		index: Number(row["idx"]),
-		content: textOf(row["content"]),
-		metadata: recordOrEmpty(row["metadata"]),
-		title: textOf(row["title"]),
-		score: Number(row["score"])
-	};
-}
-const notFound = () => dbError("not_found", "No knowledge document you can see has this id", { hint: "KNOWLEDGE_NOT_FOUND" });
-const decoder = new TextDecoder("utf-8", { fatal: true });
-function defaultExtract(file, data) {
-	if (!TEXT_TYPES.test(file.mediaType)) return Promise.reject(/* @__PURE__ */ new TypeError(`No text extractor for ${file.mediaType}; pass extract to createKnowledge`));
-	return Promise.resolve(decoder.decode(data));
-}
-const unsupported = (cause) => dbError("invalid_request", errorText(cause), { hint: "KNOWLEDGE_UNSUPPORTED" });
-/** Documents, chunks and hybrid search for retrieval. */
-function createKnowledge(options) {
-	applyTemporal(options);
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
-	const batchSize = options.batchSize ?? 64;
-	const extract = options.extract ?? defaultExtract;
-	const embedder = injectableOf("embedder", options.embedder);
-	const found = (value) => isRecord(value) ? AsyncResult.ok(documentOf(value)) : AsyncResult.err(notFound());
-	const create = (organizationId, document) => call("create_knowledge_document", {
-		tenant: organizationId,
-		title: document.title,
-		scope: document.scope,
-		scope_id: document.scopeId,
-		file_id: document.fileId,
-		source: document.source,
-		metadata: document.metadata,
-		owner: document.ownerId
-	}, documentOf);
-	const write = (documentId, chunks) => call("write_knowledge_chunks", {
-		document_id: documentId,
-		chunks: { items: chunks },
-		model: embedder?.model
-	}, (value) => value).andThen(found);
-	const fromText = (organizationId, document, text) => run(() => Promise.resolve(chunk(text, options.chunking))).andThen((chunks) => create(organizationId, document).andThen((created) => write(created.id, chunks)));
-	const embed = (values, signal) => embedder ? run(() => embedder.embed(values, signal === void 0 ? void 0 : { signal })) : AsyncResult.err(dbError("invalid_request", "createKnowledge has no embedder", { hint: "KNOWLEDGE_NO_EMBEDDER" }));
-	const process = (documentId, processOptions = {}) => AsyncResult.from(async () => {
-		let before = Number.POSITIVE_INFINITY;
-		for (;;) {
-			const pending = await service("pending_knowledge_chunks", {
-				document_id: documentId,
-				batch: batchSize
-			}, (value) => recordsOf(value, "pending_knowledge_chunks"));
-			if (!pending.ok) return pending;
-			if (pending.data.length === 0) return ok(0);
-			const vectors = await embed(pending.data.map((row) => textOf(row["content"])), processOptions.signal);
-			if (!vectors.ok) return vectors;
-			const invalid = checkVectors(vectors.data, pending.data.length);
-			if (invalid) return err(invalid);
-			const remaining = await service("set_knowledge_embeddings", {
-				document_id: documentId,
-				embeddings: { items: pending.data.map((row, index) => ({
-					idx: Number(row["idx"]),
-					hash: row["hash"],
-					embedding: vectorLiteral(vectors.data[index] ?? [])
-				})) },
-				model: embedder?.model
-			}, Number);
-			if (!remaining.ok || remaining.data === 0) return remaining;
-			if (processOptions.signal?.aborted) return ok(remaining.data);
-			if (remaining.data >= before) return ok(remaining.data);
-			before = remaining.data;
-		}
-	});
-	return {
-		documents: {
-			create,
-			get: (documentId) => call("get_knowledge_document", { document_id: documentId }, (value) => value).andThen(found),
-			list: (organizationId, listOptions = {}) => call("list_knowledge_documents", {
-				tenant: organizationId,
-				scope: listOptions.scope,
-				scope_id: listOptions.scopeId,
-				max_rows: listOptions.limit
-			}, (value) => recordsOf(value, "list_knowledge_documents").map(documentOf)),
-			write,
-			remove: (documentId) => call("delete_knowledge_document", { document_id: documentId }, (value) => value === true)
-		},
-		ingest: {
-			text: (organizationId, { text, ...document }) => fromText(organizationId, document, text),
-			file: (organizationId, fileId, document = {}) => {
-				const files = options.files;
-				if (!files) return AsyncResult.err(dbError("invalid_request", "createKnowledge has no files block", { hint: "KNOWLEDGE_NO_FILES" }));
-				return files.files.read(fileId).andThen(({ file, data }) => AsyncResult.from(async () => {
-					try {
-						return ok(await extract(file, data));
-					} catch (cause) {
-						return err(unsupported(cause));
-					}
-				}).andThen((text) => fromText(organizationId, {
-					...document,
-					title: document.title ?? file.filename,
-					fileId: file.id,
-					source: document.source ?? file.filename
-				}, text)));
-			}
-		},
-		process,
-		embedJob: () => async (payload, job, signal) => {
-			const result = await process(payload.document_id, { signal });
-			if (result.ok) return;
-			if (job.attempts >= job.maxAttempts) await service("fail_knowledge_document", {
-				document_id: payload.document_id,
-				error: result.error.message
-			}, (value) => value);
-			throw new DbException(result.error);
-		},
-		drain: (drainOptions = {}) => service("pending_knowledge_documents", { batch: drainOptions.batch }, (value) => Array.isArray(value) ? value.map(textOf) : []).andThen((ids) => AsyncResult.from(async () => {
-			const attempts = Math.max(1, drainOptions.attempts ?? 3);
-			let done = 0;
-			for (const id of ids) {
-				if (drainOptions.signal?.aborted) break;
-				let result = await process(id, drainOptions);
-				for (let attempt = 1; !result.ok && attempt < attempts && !drainOptions.signal?.aborted; attempt += 1) result = await process(id, drainOptions);
-				if (result.ok) done += 1;
-				else if (!drainOptions.signal?.aborted) await service("fail_knowledge_document", {
-					document_id: id,
-					error: result.error.message
-				}, (value) => value);
-			}
-			return ok(done);
-		})),
-		search: (organizationId, query, searchOptions = {}) => {
-			const { text, embedding } = typeof query === "string" ? {
-				text: query,
-				embedding: void 0
-			} : query;
-			return (embedding === void 0 && embedder !== void 0 && text !== void 0 && text !== "" ? embed([text], searchOptions.signal).map((vectors) => vectors[0]) : AsyncResult.ok(embedding)).andThen((value) => call("knowledge_search", {
-				tenant: organizationId,
-				query_embedding: value === void 0 ? void 0 : vectorLiteral(value),
-				query_text: text === "" ? void 0 : text,
-				scopes: searchOptions.scopes === void 0 ? void 0 : { items: searchOptions.scopes },
-				k: searchOptions.k,
-				filter: searchOptions.filter
-			}, (rows) => recordsOf(rows, "knowledge_search").map(hitOf)));
-		},
-		reembed: (reembedOptions = {}) => service("reembed_knowledge", {
-			tenant: reembedOptions.organizationId,
-			model: reembedOptions.model
-		}, Number)
-	};
-}
-//#endregion
-export { chunk as n, createKnowledge as r, checkVectors as t };

package/dist/list-query-BRt-zDF7.d.ts

@@ -1,164 +0,0 @@
-import { E as ValidationIssue, t as AsyncResult } from "./result-D7y2fT87.js";
-import { L as TableKey, M as Row, a as AnyModels, i as AnyFunctions } from "./types-6BdhkmZe.js";
-import { l as CountMode } from "./executor-DvsBbNBS.js";
-import { At as OrderByArg, Ct as IncludeArg, D as OffsetPage, It as SelectArg, M as RepositoryOf, Mt as Payload, O as OffsetPageArgs, t as BetterSupabase, v as CursorPage, w as FindExt, y as CursorPageArgs, zt as WhereInput } from "./define-CJJkkr1-.js";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/list/list-query.d.ts
-/** Facet value meaning "not set": filters with `is null`. */
-declare const UNSET = "__unset__";
-type Column<M extends AnyModels, T extends keyof M> = Extract<keyof Row<M, T>, string>;
-type TextColumn<M extends AnyModels, T extends keyof M> = { [K in Column<M, T>]: [NonNullable<Row<M, T>[K]>] extends [string] ? K : never; }[Column<M, T>];
-/** `offset` pages by number; `cursor` continues after the last row (keyset). */
-type ListPagination = "offset" | "cursor";
-interface ListQueryConfig<M extends AnyModels, T extends keyof M, S extends string, F extends string, C extends boolean = boolean, P extends ListPagination = ListPagination> {
-  /**
-   * Also count rows per facet value, with one grouped aggregate per facet
-   * that runs next to the page: one wave. Needs PostgREST aggregates.
-   */
-  readonly facetCounts?: C;
-  /** How the page total is counted. Defaults to `'planned'`, the planner's estimate. */
-  readonly count?: CountMode;
-  /** Text columns matched case-insensitively (OR), or a full-text column. */
-  readonly search?: readonly TextColumn<M, T>[] | {
-    readonly fts: Column<M, T>;
-    readonly config?: string;
-  };
-  /** Filterable columns by URL key. Values are validated against enums and CHECK unions. */
-  readonly facets?: { readonly [K in F]: Column<M, T>; };
-  /** Named orderings. Add a unique column last for stable pages. */
-  readonly sorts: { readonly [K in S]: OrderByArg<M, T>; };
-  readonly defaultSort: NoInfer<S>;
-  /**
-   * `cursor` takes an `after` cursor instead of `page` and returns
-   * `nextCursor`: the cost of a page stays the same however deep it is, and
-   * rows inserted meanwhile don't shift it. Defaults to `offset`.
-   */
-  readonly pagination?: P;
-  /** Defaults to 50. */
-  readonly pageSize?: number;
-  /** Defaults to 200. */
-  readonly maxPageSize?: number;
-  /** Defaults to 200 characters. */
-  readonly maxSearchLength?: number;
-  /**
-   * Most values counted per facet; a facet with more lists its key in
-   * `facetCountsTruncated`. Defaults to 100.
-   */
-  readonly facetLimit?: number;
-}
-interface ListQuery<S extends string, F extends string> {
-  readonly q?: string;
-  readonly sort: S;
-  /** 1-based. Always 1 with cursor pagination. */
-  readonly page: number;
-  /** Cursor pagination: the `nextCursor` of the previous page. */
-  readonly after?: string;
-  readonly size: number;
-  readonly facets: { readonly [K in F]?: readonly string[]; };
-}
-/** Typed input (JSON APIs, actions, MCP tools). Everything is optional. */
-interface ListQueryInput<S extends string, F extends string> {
-  readonly q?: string;
-  readonly sort?: S;
-  readonly page?: number;
-  readonly after?: string;
-  readonly size?: number;
-  readonly facets?: { readonly [K in F]?: readonly string[]; };
-}
-/** URL input: `URLSearchParams` or a Next.js `searchParams` record. */
-type ListSearchParams = URLSearchParams | Readonly<Record<string, string | readonly string[] | undefined>>;
-type ListParseResult<S extends string, F extends string> = {
-  readonly ok: true;
-  readonly value: ListQuery<S, F>;
-  readonly issues?: undefined;
-} | {
-  readonly ok: false;
-  readonly value?: undefined;
-  readonly issues: readonly ValidationIssue[];
-};
-interface ParserSpec<V> {
-  parse(value: string): V | null;
-  serialize(value: V): string;
-}
-interface OpenApiParameter {
-  readonly name: string;
-  readonly in: "query";
-  readonly required: false;
-  readonly description: string;
-  readonly schema: Readonly<Record<string, unknown>>;
-  readonly style?: "form";
-  readonly explode?: boolean;
-}
-interface FacetInfo {
-  readonly key: string;
-  readonly column: string;
-  readonly nullable: boolean;
-  /** Allowed values when the column is an enum or CHECK union. */
-  readonly values?: readonly string[];
-}
-/** Rows per facet value, keyed by facet and then by value (`UNSET` for empty). */
-type FacetCounts<F extends string> = { readonly [K in F]: Readonly<Record<string, number>>; };
-/** A page of a list; with `facetCounts: true`, also the counts per facet value. */
-type ListPage<R, F extends string, C extends boolean, P extends ListPagination = "offset"> = ([P] extends ["cursor"] ? CursorPage<R> : OffsetPage<R>) & ([C] extends [true] ? FacetCountFields<F> : [C] extends [false] ? unknown : Partial<FacetCountFields<F>>);
-/** The facet fields of a page with `facetCounts: true`. */
-interface FacetCountFields<F extends string> {
-  readonly facetCounts: FacetCounts<F>;
-  /** Facets with more values than `facetLimit`, whose counts are cut. */
-  readonly facetCountsTruncated: readonly F[];
-}
-interface ListDefinition<M extends AnyModels, T extends TableKey<M>, E, S extends string, F extends string, C extends boolean = false, P extends ListPagination = "offset"> {
-  readonly table: T;
-  readonly pagination: P;
-  readonly defaults: ListQuery<S, F>;
-  readonly facets: readonly FacetInfo[];
-  /** Validates typed input or URL params. Also a Standard Schema (`schema`). */
-  parse(input: ListQueryInput<S, F> | ListSearchParams | undefined): ListParseResult<S, F>;
-  readonly schema: StandardSchemaV1<ListQueryInput<S, F> | ListSearchParams | undefined, ListQuery<S, F>>;
-  /** URL params, leaving out defaults. */
-  toSearchParams(query: Partial<ListQuery<S, F>>): URLSearchParams;
-  /** `{ parse, serialize }` per URL key, for routers and nuqs (`list.nuqs(createParser)`). */
-  readonly parsers: ListParsers<S, F>;
-  nuqs<P>(createParser: (spec: ParserSpec<unknown>) => P): { readonly [K in keyof ListParsers<S, F>]: P; };
-  /** Repository arguments: `where`, `orderBy`, `size`, and `page` and `count` or `after`. */
-  args(query: ListQuery<S, F>): [P] extends ["cursor"] ? CursorPageArgs<M, T> : OffsetPageArgs<M, T>;
-  /**
-   * Runs the list against a table, merging your `select`, `include`, `where`
-   * and `count`. One request, plus one per facet for `facetCounts`, always one wave.
-   */
-  run<const A extends ListExtra<M, T> & FindExt<E, M, T>>(db: { readonly [K in T]: RepositoryOf<M, K, E>; }, query: ListQuery<S, F>, extra?: A): AsyncResult<ListPage<Payload<M, T, A>, F, C, P>>;
-  /** OpenAPI 3.1 query parameters. */
-  readonly openapi: readonly OpenApiParameter[];
-  /** JSON Schema of the typed input, e.g. for MCP tool arguments. */
-  readonly jsonSchema: Readonly<Record<string, unknown>>;
-}
-interface ListExtra<M extends AnyModels, T extends keyof M> {
-  readonly select?: SelectArg<M, T>;
-  readonly include?: IncludeArg<M, T>;
-  readonly where?: WhereInput<M, T>;
-  /** Overrides the config's `count` for this run. */
-  readonly count?: CountMode;
-}
-type ListParsers<S extends string, F extends string> = {
-  readonly q: ParserSpec<string>;
-  readonly sort: ParserSpec<S>;
-  readonly page: ParserSpec<number>;
-  readonly after: ParserSpec<string>;
-  readonly size: ParserSpec<number>;
-} & { readonly [K in F]: ParserSpec<readonly string[]>; };
-/**
- * A reusable list endpoint for one table: search, facets, sorts and
- * pagination, validated from URL params or typed input, with URL parsers,
- * OpenAPI parameters and a JSON Schema derived from the same definition.
- *
- * ```ts
- * export const customerList = defineListQuery(betterSupabase, 'customers', {
- *   search: ['name', 'kvk'],
- *   facets: { status: 'status' },
- *   sorts: { name: { name: 'asc' }, newest: [{ createdAt: 'desc' }, { id: 'asc' }] },
- *   defaultSort: 'newest',
- * });
- * ```
- */
-declare function defineListQuery<M extends AnyModels, D, Fn extends AnyFunctions, E, T extends TableKey<M>, const S extends string, const F extends string = never, const C extends boolean = false, const P extends ListPagination = "offset">(betterSupabase: BetterSupabase<M, D, Fn, E>, table: T, config: ListQueryConfig<M, T, S, F, C, P>): ListDefinition<M, T, E, S, F, C, P>;
-//#endregion
-export { defineListQuery as _, ListExtra as a, ListParseResult as c, ListQueryConfig as d, ListQueryInput as f, UNSET as g, ParserSpec as h, ListDefinition as i, ListParsers as l, OpenApiParameter as m, FacetCounts as n, ListPage as o, ListSearchParams as p, FacetInfo as r, ListPagination as s, FacetCountFields as t, ListQuery as u };