better-supabase 0.13.0 → 0.14.0

package/dist/vue-bind-CFxon-Vs.js

@@ -0,0 +1,45 @@
+import { getCurrentInstance, getCurrentScope, inject, onMounted, onScopeDispose, shallowRef } from "vue";
+//#region src/vue/context.ts
+const CLIENT = Symbol("better-supabase");
+/** What `app.use(betterSupabase(bs))` provides. */
+function useContext() {
+	const context = inject(CLIENT, null);
+	if (!context) throw new Error("better-supabase: install the plugin with app.use(betterSupabase(bs))");
+	return context;
+}
+/**
+* Runs `start` on mount in a component, at once elsewhere (an effect scope),
+* and never during server rendering.
+*/
+function onClient(start) {
+	if (getCurrentInstance()) onMounted(start);
+	else start();
+}
+//#endregion
+//#region src/blocks/vue-bind.ts
+/**
+* Keeps `state` current from mount (at once in an effect scope, never during
+* server rendering), and disposes the controller with the component or scope.
+*/
+function bindVueController(controller) {
+	const state = shallowRef(controller.getSnapshot());
+	let unsubscribe;
+	onClient(() => {
+		const sync = () => {
+			state.value = controller.getSnapshot();
+		};
+		unsubscribe = controller.subscribe(sync);
+		sync();
+	});
+	if (getCurrentScope()) onScopeDispose(() => {
+		unsubscribe?.();
+		controller.dispose();
+	});
+	return {
+		state,
+		actions: controller.actions,
+		controller
+	};
+}
+//#endregion
+export { useContext as i, CLIENT as n, onClient as r, bindVueController as t };

package/dist/vue-bind-TPkbLl4z.d.ts

@@ -0,0 +1,11 @@
+import { n as Controller } from "./controller-DAD4hbl4.js";
+import { ShallowRef } from "vue";
+//#region src/blocks/vue-bind.d.ts
+/** A block controller in a Vue component: `state` follows the controller. */
+interface VueController<S, A> {
+  readonly state: Readonly<ShallowRef<S>>;
+  readonly actions: A;
+  readonly controller: Controller<S, A>;
+}
+//#endregion
+export { VueController as t };

package/dist/vue-controller-WtbuT-Ux.js

@@ -0,0 +1,13 @@
+import { n as withEnv, t as blockEnv } from "./block-env-DJiUu1fq.js";
+import { i as useContext, t as bindVueController } from "./vue-bind-CFxon-Vs.js";
+//#region src/blocks/vue-controller.ts
+/**
+* Makes a controller once and keeps `state` current. Its work starts on mount
+* (at once in an effect scope, never during server rendering), and the
+* controller is disposed with the component or scope.
+*/
+function useBlockController(create, options, usesEnv = true) {
+	return bindVueController(create(withEnv(options, usesEnv ? () => blockEnv(useContext().client) : void 0)));
+}
+//#endregion
+export { useBlockController as t };

package/dist/watch-CfMT6vX7.js

@@ -0,0 +1,139 @@
+import { r as isPlainObject } from "./clone-CkG0-hlI.js";
+import { r as err, s as toDbError } from "./result-B3m7xtRY.js";
+//#region src/core/share.ts
+function sameValue(prev, next) {
+	if (Object.is(prev, next)) return true;
+	if (typeof prev !== "object" || typeof next !== "object") return false;
+	if (prev === null || next === null) return false;
+	return Object.getPrototypeOf(prev) === Object.getPrototypeOf(next) && !Array.isArray(prev) && !isPlainObject(prev) && "toJSON" in prev && typeof prev.toJSON === "function" && JSON.stringify(prev) === JSON.stringify(next);
+}
+function idOf(value) {
+	return isPlainObject(value) ? value["id"] : void 0;
+}
+/**
+* `next` with every part that equals `prev` replaced by `prev`'s object, so
+* unchanged rows keep their identity and `memo` skips them. Array items match
+* by their `id` when they have one (a reordered list keeps its rows), else by
+* position. Returns `prev` itself when nothing changed.
+*/
+function shareStructure(prev, next) {
+	if (sameValue(prev, next)) return prev;
+	if (Array.isArray(prev) && Array.isArray(next)) {
+		const before = prev;
+		const after = next;
+		const byId = /* @__PURE__ */ new Map();
+		for (const item of before) {
+			const id = idOf(item);
+			if (id !== void 0) byId.set(id, item);
+		}
+		let same = before.length === after.length;
+		const shared = after.map((item, index) => {
+			const id = idOf(item);
+			const value = shareStructure(id === void 0 ? before[index] : byId.get(id), item);
+			if (value !== before[index]) same = false;
+			return value;
+		});
+		return same ? prev : shared;
+	}
+	if (isPlainObject(prev) && isPlainObject(next)) {
+		const keys = Object.keys(next);
+		let same = keys.length === Object.keys(prev).length;
+		const shared = {};
+		for (const key of keys) {
+			const value = shareStructure(prev[key], next[key]);
+			if (!Object.hasOwn(prev, key) || value !== prev[key]) same = false;
+			shared[key] = value;
+		}
+		return same ? prev : shared;
+	}
+	return next;
+}
+//#endregion
+//#region src/powersync/watch.ts
+/**
+* Reruns a repository call whenever PowerSync reports a change to one of
+* `tables`: local writes and synced rows alike. The same call works with lists,
+* aggregates and single rows. Unchanged rows keep their identity between runs,
+* and a run that changes nothing calls no `onResult`. Returns a function that
+* stops it.
+*
+* ```ts
+* const stop = watch(powersync, () => customerList.run(db, query), {
+*   tables: ["customers"],
+*   onResult: (page) => render(page),
+* });
+* ```
+*/
+function watch(db, query, options) {
+	if (!db.onChange) throw new TypeError("better-supabase: watch() needs a PowerSync database with onChange()");
+	const refresh = options.refresh ?? {};
+	if (refresh.onReconnect && !db.registerListener) throw new TypeError("better-supabase: watch() refresh.onReconnect needs a PowerSync database with registerListener()");
+	const signal = options.signal;
+	if (signal?.aborted) return () => void 0;
+	const controller = new AbortController();
+	const stop = () => {
+		controller.abort();
+	};
+	signal?.addEventListener("abort", stop, { once: true });
+	let latest = 0;
+	let previous;
+	const sharing = options.structuralSharing ?? true;
+	const rerun = async () => {
+		latest += 1;
+		const run = latest;
+		let result;
+		try {
+			result = await query();
+		} catch (cause) {
+			result = err(toDbError(cause));
+		}
+		if (run !== latest || controller.signal.aborted) return;
+		if (sharing) {
+			const shared = shareStructure(previous, result);
+			if (shared === previous) return;
+			result = shared;
+		}
+		previous = result;
+		options.onResult(result);
+	};
+	rerun();
+	const unsubscribe = db.onChange({ onChange: rerun }, {
+		tables: [...options.tables],
+		signal: controller.signal,
+		...options.throttleMs === void 0 ? {} : { throttleMs: options.throttleMs }
+	});
+	const timer = refresh.everyMs === void 0 ? void 0 : setInterval(() => {
+		if (db.currentStatus?.connected === false) return;
+		rerun();
+	}, refresh.everyMs);
+	let connected = db.currentStatus?.connected ?? true;
+	const unlisten = refresh.onReconnect && db.registerListener ? db.registerListener({ statusChanged: (status) => {
+		const reconnected = status.connected && !connected;
+		connected = status.connected;
+		if (reconnected) rerun();
+	} }) : void 0;
+	const cleanup = () => {
+		clearInterval(timer);
+		unlisten?.();
+	};
+	controller.signal.addEventListener("abort", cleanup, { once: true });
+	return () => {
+		signal?.removeEventListener("abort", stop);
+		stop();
+		unsubscribe();
+	};
+}
+/**
+* The SQLite table names of app table keys (`customerTags` to `customer_tags`).
+* Pass the executor's `tableName` when it renames tables, so `watch` listens to
+* the names the queries read.
+*/
+function sqliteTables(betterSupabase, keys, options = {}) {
+	return keys.map((key) => {
+		const table = betterSupabase.meta.tables[key];
+		if (!table) throw new TypeError(`better-supabase: unknown table "${key}"`);
+		return options.tableName ? options.tableName(table) : table.name;
+	});
+}
+//#endregion
+export { watch as n, sqliteTables as t };

package/dist/watch-DziJudwj.d.ts

@@ -0,0 +1,93 @@
+import { b as DbError, f as Result } from "./result-C6jDfedy.js";
+import { M as AnyFunctions, N as AnyModels, lt as SchemaMeta, mt as TableKey } from "./executor-CPyrQdjh.js";
+import { J as QuerySpec, t as BetterSupabase } from "./define-Dw7pRO4h.js";
+import { i as ListDefinition } from "./list-query-BtluNnYk.js";
+import { c as SqliteCompilerOptions, m as SqlitePlan, t as PowerSyncDatabaseLike } from "./executor-BElVQpaB.js";
+import { t as Compiler } from "./compiler-BCyHFI6n.js";
+//#region src/powersync/compiler.d.ts
+declare const sqliteCompiler: Compiler<SqlitePlan>;
+interface CheckSqliteOptions extends SqliteCompilerOptions {
+  /**
+   * Return every error instead of the first, one per distinct message. With a
+   * `fallback` executor, these are the reads that run on the server.
+   */
+  readonly all?: boolean;
+}
+/**
+ * Compiles every operation a list definition runs (the page, its count and the
+ * facet counts), or the one read a `QuerySpec` from `betterSupabase.spec`
+ * describes, for SQLite, without a database. Returns the first `unsupported` or
+ * `invalid_request` error, so a test or a dev build fails before a native
+ * screen does. With `all: true`, returns every error, an empty array when the
+ * whole list runs on SQLite.
+ *
+ * ```ts
+ * expect(await checkSqlite(betterSupabase, customerList)).toEqual({
+ *   ok: true,
+ *   data: undefined,
+ * });
+ * expect(
+ *   await checkSqlite(betterSupabase, customerList, { all: true }),
+ * ).toEqual([]);
+ * ```
+ */
+declare function checkSqlite<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>, S extends string, Fa extends string, C extends boolean, P extends "offset" | "cursor">(betterSupabase: BetterSupabase<M, D, F, E>, list: ListDefinition<M, T, E, S, Fa, C, P> | QuerySpec<TableKey<M>>, options: CheckSqliteOptions & {
+  readonly all: true;
+}): Promise<readonly DbError[]>;
+declare function checkSqlite<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>, S extends string, Fa extends string, C extends boolean, P extends "offset" | "cursor">(betterSupabase: BetterSupabase<M, D, F, E>, list: ListDefinition<M, T, E, S, Fa, C, P> | QuerySpec<TableKey<M>>, options?: CheckSqliteOptions & {
+  readonly all?: false;
+}): Promise<Result<undefined>>;
+//#endregion
+//#region src/powersync/watch.d.ts
+interface WatchOptions<T> {
+  /**
+   * SQLite tables whose changes rerun the query (`sqliteTables()` maps app
+   * keys).
+   */
+  readonly tables: readonly string[];
+  /** Called with the first result, then after every change to `tables`. */
+  readonly onResult: (result: Result<T>) => void;
+  readonly signal?: AbortSignal;
+  /** The least time between two runs. Defaults to PowerSync's 30 ms. */
+  readonly throttleMs?: number;
+  /**
+   * Keeps unchanged rows' object identity across runs and skips `onResult` when
+   * a run returns what the last one did. Defaults to true.
+   */
+  readonly structuralSharing?: boolean;
+  /**
+   * Reruns that don't wait for a local change, for reads that run on the
+   * executor's server `fallback`: `everyMs` reruns on an interval (skipped
+   * while PowerSync reports it is offline), and `onReconnect` reruns when
+   * PowerSync connects again. `onReconnect` needs `registerListener()`.
+   */
+  readonly refresh?: {
+    readonly everyMs?: number;
+    readonly onReconnect?: boolean;
+  };
+}
+/**
+ * Reruns a repository call whenever PowerSync reports a change to one of
+ * `tables`: local writes and synced rows alike. The same call works with lists,
+ * aggregates and single rows. Unchanged rows keep their identity between runs,
+ * and a run that changes nothing calls no `onResult`. Returns a function that
+ * stops it.
+ *
+ * ```ts
+ * const stop = watch(powersync, () => customerList.run(db, query), {
+ *   tables: ["customers"],
+ *   onResult: (page) => render(page),
+ * });
+ * ```
+ */
+declare function watch<T>(db: PowerSyncDatabaseLike, query: () => PromiseLike<Result<T>>, options: WatchOptions<T>): () => void;
+/**
+ * The SQLite table names of app table keys (`customerTags` to `customer_tags`).
+ * Pass the executor's `tableName` when it renames tables, so `watch` listens to
+ * the names the queries read.
+ */
+declare function sqliteTables(betterSupabase: {
+  readonly meta: SchemaMeta;
+}, keys: readonly string[], options?: SqliteCompilerOptions): string[];
+//#endregion
+export { checkSqlite as a, CheckSqliteOptions as i, sqliteTables as n, sqliteCompiler as o, watch as r, WatchOptions as t };

package/dist/watch-topic-CIT3UlAh.d.ts

@@ -0,0 +1,31 @@
+import { c as RealtimeClient, p as SubscriptionStatus } from "./topic-D9j8G2dw.js";
+//#region src/realtime/watch-topic.d.ts
+interface TopicWatch {
+  readonly onMessage: (event: string, payload: unknown) => void;
+  readonly onRejoin: () => void;
+  readonly onStatus: (status: SubscriptionStatus) => void;
+}
+/**
+ * A joined topic: `leave` is safe to call twice, `send` broadcasts to the other
+ * members.
+ */
+interface TopicHandle {
+  readonly leave: () => void;
+  readonly send: (event: string, payload: Readonly<Record<string, unknown>>) => void;
+}
+/**
+ * Joins a private topic and reports its messages, rejoins and status: the
+ * realtime port of the block controllers. `topicPort(supabase)` is the default;
+ * a test passes a fake.
+ */
+type TopicPort = (topic: string, watch: TopicWatch) => TopicHandle;
+/**
+ * Joins a private topic and returns its handle. Watches on the same client and
+ * topic share one channel, as `defineTopic` subscriptions do, and the channel
+ * closes when the last one leaves.
+ */
+declare function watchTopic(supabase: RealtimeClient, topic: string, watch: TopicWatch): TopicHandle;
+/** The realtime port over a supabase-js client. */
+declare function topicPort(supabase: RealtimeClient): TopicPort;
+//#endregion
+export { watchTopic as a, topicPort as i, TopicPort as n, TopicWatch as r, TopicHandle as t };

package/dist/wire-Bizdxvp-.js

@@ -0,0 +1,66 @@
+import { t as DbException } from "./db-exception-Lngc1W49.js";
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { d as temporalText } from "./temporal-DLZlWbOi.js";
+import { t as temporal } from "./temporal-required-B8qQHYbI.js";
+//#region src/ir/wire.ts
+/** ISO text of a `Date`; an invalid date has none. */
+function dateText(value) {
+	if (Number.isNaN(value.getTime())) throw new DbException(dbError("invalid_value", "The Date is invalid"));
+	return value.toISOString();
+}
+/**
+* Wire form of an app value: Temporal values and `Date` to ISO text, `bigint`
+* to decimal text.
+*/
+function encodeValue(value) {
+	if (typeof value !== "object" || value === null) return typeof value === "bigint" ? value.toString() : value;
+	if (value instanceof Date) return dateText(value);
+	const text = temporalText(value);
+	if (text !== void 0) return text;
+	if (Array.isArray(value)) return value.map(encodeValue);
+	return value;
+}
+/** Postgres timestamps can be `infinity`; Temporal has no such value. */
+function finite(value, type) {
+	const text = String(value);
+	if (text === "infinity" || text === "-infinity") throw new DbException(dbError("invalid_value", `${text} can't be held by a Temporal.${type}`));
+	return text;
+}
+const TIMESTAMPTZ = /^(\d{4,})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(?:(Z)|([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)$/;
+/**
+* `timestamptz` text in UTC as ISO 8601 with a `Z`, from either PostgREST's
+* form (`2026-10-21T07:10:00.123456+00:00`) or Postgres text (`2026-10-21
+* 07:10:00.123456+02`). The fraction keeps every digit it had, so no
+* microsecond is lost; `infinity` and `-infinity` pass through.
+*/
+function utcText(value) {
+	const text = String(value);
+	if (text === "infinity" || text === "-infinity") return text;
+	const match = TIMESTAMPTZ.exec(text);
+	if (!match) throw new DbException(dbError("invalid_value", `${text} is not a timestamptz`));
+	const [, year, month, day, hour, minute, second, fraction, zulu, sign] = match;
+	const offset = zulu ? 0 : (sign === "-" ? -1 : 1) * (Number(match[10]) * 3600 + Number(match[11] ?? 0) * 60 + Number(match[12] ?? 0));
+	const utc = /* @__PURE__ */ new Date(0);
+	utc.setUTCFullYear(Number(year), Number(month) - 1, Number(day));
+	utc.setUTCHours(Number(hour), Number(minute), Number(second) - offset, 0);
+	if (Number.isNaN(utc.getTime())) throw new DbException(dbError("invalid_value", `${text} is not a timestamptz`));
+	return `${utc.toISOString().slice(0, -5)}${fraction ? `.${fraction}` : ""}Z`;
+}
+/** App form of one wire scalar for a column with `codec`. */
+function decodeScalar(codec, value) {
+	if (value === null || value === void 0) return value;
+	switch (codec) {
+		case "instant": return temporal().Instant.from(finite(value, "Instant"));
+		case "plainDateTime": return temporal().PlainDateTime.from(finite(value, "PlainDateTime"));
+		case "bigint": return BigInt(value);
+		case "string": return String(value);
+		case "utcString": return utcText(value);
+		default: return codec;
+	}
+}
+/** App form of a wire value for a column with `codec`. */
+function decodeValue(codec, value) {
+	return Array.isArray(value) ? value.map((item) => decodeScalar(codec, item)) : decodeScalar(codec, value);
+}
+//#endregion
+export { encodeValue as i, decodeScalar as n, decodeValue as r, dateText as t };

package/dist/work-items-Cnntm8ij.d.ts

@@ -0,0 +1,238 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
+import { n as ExtraFields, r as FieldsOf } from "./block-fields-3w4MZr8U.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "./block-helpers-BaugZlJV.js";
+import { t as BlockTransport } from "./block-transport-d53POsem.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+//#region src/blocks/work-items/work-items.d.ts
+/** The state a stage's category sets; `completed` and `canceled` are closed. */
+type WorkItemState = "triage" | "backlog" | "unstarted" | "started" | "completed" | "canceled";
+type CloseReason = "completed" | "not_planned" | "duplicate";
+/** A work item. `F` types the extra columns the `fields` schema describes. */
+interface WorkItem<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly number: bigint;
+  /** `TASK-12`, or the number-sequences format. */
+  readonly identifier: string;
+  readonly title: string;
+  readonly body?: string;
+  readonly parentId?: string;
+  readonly teamId?: string;
+  readonly projectId?: string;
+  readonly iterationId?: string;
+  /** 0 none, 1 urgent, 2 high, 3 medium, 4 low. */
+  readonly priority: number;
+  readonly estimate?: number;
+  /** Its own progress; `tree` rolls children up when it has none. */
+  readonly progress?: number;
+  readonly startAt?: Temporal.Instant;
+  readonly endAt?: Temporal.Instant;
+  readonly dueAt?: Temporal.Instant;
+  readonly pipelineId?: string;
+  readonly stageId?: string;
+  readonly stageEnteredAt?: Temporal.Instant;
+  readonly state: WorkItemState;
+  readonly closeReason?: CloseReason;
+  readonly closedAt?: Temporal.Instant;
+  /** A locked item keeps its dates, as a locked Gantt bar. */
+  readonly locked: boolean;
+  readonly rank: string;
+  readonly assigneeIds: readonly string[];
+  /** How many checklist items it has, and how many are done. */
+  readonly checklist: {
+    readonly total: number;
+    readonly done: number;
+  };
+  /** Its repeat rule, with the reminders block. */
+  readonly recurrence?: WorkItemRecurrence;
+  /** The item this one repeats. */
+  readonly recursFromId?: string;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+  readonly archived: boolean;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface WorkItemInput<F extends object = Record<never, never>> {
+  readonly title: string;
+  readonly body?: string;
+  readonly parentId?: string;
+  readonly teamId?: string;
+  readonly projectId?: string;
+  readonly iterationId?: string;
+  readonly priority?: number;
+  readonly estimate?: number;
+  readonly progress?: number;
+  readonly startAt?: Temporal.Instant;
+  readonly endAt?: Temporal.Instant;
+  readonly dueAt?: Temporal.Instant;
+  readonly pipelineId?: string;
+  readonly stageId?: string;
+  /**
+   * Files to attach: ids of your own attachments in the organization that have
+   * no subject yet, such as uploads made before the item existed.
+   */
+  readonly attachmentIds?: readonly string[];
+  /** The extra columns to set. */
+  readonly fields?: Partial<F>;
+}
+type WorkItemField = "title" | "body" | "parentId" | "teamId" | "projectId" | "iterationId" | "priority" | "estimate" | "progress" | "startAt" | "endAt" | "dueAt" | "stageId" | "closeReason" | "attachments";
+/** A work item's repeat rule: an RFC 5545 RRULE from `dtstart` in `tzid`. */
+interface WorkItemRecurrence {
+  readonly rrule: string;
+  readonly tzid: string;
+  readonly dtstart: Temporal.Instant;
+}
+interface ChecklistItem {
+  readonly id: string;
+  readonly workItemId: string;
+  readonly title: string;
+  readonly done: boolean;
+  readonly doneAt?: Temporal.Instant;
+  readonly doneBy?: string;
+  readonly rank: string;
+  readonly createdAt: Temporal.Instant;
+}
+interface ChecklistItemInput {
+  readonly title?: string;
+  readonly done?: boolean;
+  /** A rank key; a new item without one goes last. */
+  readonly rank?: string;
+}
+/** `all` watches, `participating` follows, `ignore` mutes. */
+type WorkItemWatchLevel = "all" | "participating" | "ignore";
+interface WorkItemWatcher {
+  readonly userId: string;
+  readonly level: Exclude<WorkItemWatchLevel, "ignore">;
+}
+/**
+ * One cell edit or drag: a built-in field or an extra column. `null` clears the
+ * field.
+ */
+interface WorkItemChange<F extends object = Record<never, never>> {
+  readonly workItemId: string;
+  readonly field: WorkItemField | (keyof F & string);
+  readonly value: unknown;
+}
+interface WorkItemChangeResult {
+  readonly accepted: readonly {
+    readonly workItemId: string;
+    readonly field: string;
+  }[];
+  readonly rejected: readonly {
+    readonly workItemId: string;
+    readonly field: string;
+    readonly hint?: string;
+    readonly reason: string;
+  }[];
+}
+/** A node of `tree`, for a Gantt chart or a nested list. */
+interface WorkItemNode {
+  readonly id: string;
+  readonly parentId?: string;
+  readonly identifier: string;
+  readonly title: string;
+  readonly state: WorkItemState;
+  readonly startAt?: Temporal.Instant;
+  readonly endAt?: Temporal.Instant;
+  readonly dueAt?: Temporal.Instant;
+  readonly locked: boolean;
+  readonly depth: number;
+  readonly progress: number;
+}
+interface WorkItemListOptions {
+  readonly teamId?: string;
+  readonly projectId?: string;
+  readonly iterationId?: string;
+  readonly parentId?: string;
+  readonly assigneeId?: string;
+  readonly states?: readonly WorkItemState[];
+  /** Only items that aren't completed or canceled. */
+  readonly open?: boolean;
+  /** Matches the title, or the start of the identifier. */
+  readonly search?: string;
+  /** Continues after this item. */
+  readonly after?: string;
+  readonly limit?: number;
+}
+interface Project {
+  readonly id: string;
+  readonly key: string;
+  readonly name: string;
+  readonly ownerId?: string;
+  readonly status: "planned" | "active" | "paused" | "completed" | "canceled";
+  readonly startOn?: Temporal.PlainDate;
+  readonly targetOn?: Temporal.PlainDate;
+  /** The share of its items that are completed, canceled ones left out. */
+  readonly progress?: number;
+}
+interface Iteration {
+  readonly id: string;
+  readonly teamId?: string;
+  readonly name: string;
+  readonly startsOn: Temporal.PlainDate;
+  readonly endsOn: Temporal.PlainDate;
+}
+interface WorkItems<F extends object = Record<never, never>> {
+  create(organizationId: string, input: WorkItemInput<F>, assigneeIds?: readonly string[]): AsyncResult<WorkItem<F>>;
+  /** Extra column changes are validated with the `fields` schema first. */
+  update(changes: readonly WorkItemChange<F>[]): AsyncResult<WorkItemChangeResult>;
+  /** Replaces the assignees; new ones are notified and every one watches. */
+  assign(workItemId: string, userIds: readonly string[]): AsyncResult<number>;
+  archive(workItemId: string, archived?: boolean): AsyncResult<boolean>;
+  remove(workItemId: string): AsyncResult<boolean>;
+  tree(rootId: string): AsyncResult<WorkItemNode[]>;
+  /** One item you can read, or `undefined`. */
+  get(workItemId: string): AsyncResult<WorkItem<F> | undefined>;
+  checklist(workItemId: string): AsyncResult<ChecklistItem[]>;
+  /** Adds a checklist item, or changes the one `checklistItemId` names. */
+  saveChecklistItem(workItemId: string, input: ChecklistItemInput, checklistItemId?: string): AsyncResult<ChecklistItem>;
+  removeChecklistItem(checklistItemId: string): AsyncResult<boolean>;
+  /**
+   * Makes the item repeat (`null` stops it). Needs the reminders block;
+   * `workItemRecurrenceSink` creates the next item when one is completed.
+   */
+  setRecurrence(workItemId: string, rule: {
+    readonly rrule: string;
+    readonly tzid?: string;
+  } | null): AsyncResult<WorkItemRecurrence | undefined>;
+  /** Creates the next item of a repeating one. Service only, idempotent. */
+  repeat(workItemId: string, dueAt: Temporal.Instant): AsyncResult<WorkItem<F>>;
+  /** Watches, follows or mutes an item (`null` clears). Needs notifications. */
+  watch(workItemId: string, level: WorkItemWatchLevel | null): AsyncResult<boolean>;
+  watchers(workItemId: string): AsyncResult<WorkItemWatcher[]>;
+  list(organizationId: string, options?: WorkItemListOptions): AsyncResult<WorkItem<F>[]>;
+  saveProject(organizationId: string, project: Partial<Omit<Project, "id" | "progress" | "startOn" | "targetOn">> & {
+    readonly id?: string;
+    readonly startOn?: Temporal.PlainDate | null;
+    readonly targetOn?: Temporal.PlainDate | null;
+    readonly archived?: boolean;
+  }): AsyncResult<Project>;
+  saveIteration(organizationId: string, iteration: Partial<Omit<Iteration, "id">> & {
+    readonly id?: string;
+  }): AsyncResult<Iteration>;
+}
+interface WorkItemsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the item's extra columns
+   * (`blocks.work-items.options.extraColumns`), keyed by database name. It
+   * types and parses them on reads, and validates them on `create` and
+   * `update`.
+   */
+  readonly fields?: S;
+  readonly hooks?: NoInfer<BlockHooks<WorkItems<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The work-items block: issues and tasks on pipelines, with batched edits for a
+ * grid or a Gantt chart, assignees, a progress tree, projects and iterations.
+ */
+declare function createWorkItems<S extends StandardSchemaV1 | undefined = undefined>(options: WorkItemsOptions<S>): WorkItems<FieldsOf<S>>;
+//#endregion
+export { WorkItems as _, Project as a, WorkItemChangeResult as c, WorkItemListOptions as d, WorkItemNode as f, WorkItemWatcher as g, WorkItemWatchLevel as h, Iteration as i, WorkItemField as l, WorkItemState as m, ChecklistItemInput as n, WorkItem as o, WorkItemRecurrence as p, CloseReason as r, WorkItemChange as s, ChecklistItem as t, WorkItemInput as u, WorkItemsOptions as v, createWorkItems as y };