better-supabase 0.12.0 → 0.14.0

package/dist/streams/index.d.ts

@@ -1,25 +1,31 @@
-import { T as ErrorMapper, t as AsyncResult } from "../result-BREt7qOh.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../block-transport-DezJPPA0.js";
-import { a as StreamStatus, i as StreamReadOptions, n as StreamOpenOptions, o as StreamStore, r as StreamPurgeOptions, t as StreamAppendResult } from "../store-B18bIvKc.js";
+import { T as ErrorMapper, t as AsyncResult } from "../result-C6jDfedy.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../block-transport-d53POsem.js";
+import { a as StreamStatus, i as StreamReadOptions, n as StreamOpenOptions, o as StreamStore, r as StreamPurgeOptions, t as StreamAppendResult } from "../store-o0HwYXl8.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 //#region src/streams/postgres.d.ts
 interface PostgresStreamStoreOptions {
-  /** `sqlTransport(postgres.asService())` for the writer; the owner's transport for reads. */
+  /**
+   * `sqlTransport(postgres.asService())` for the writer; the owner's transport
+   * for reads.
+   */
   readonly transport: BlockTransport;
   /** The schema of the `streams` module. Defaults to `better_supabase`. */
   readonly schema?: string;
   readonly mappers?: readonly ErrorMapper[];
   /**
-   * `realtime` (the default) pings the stream's private topic after each
-   * batch; `poll` skips the ping for apps near the Realtime message quota,
-   * and readers poll instead.
+   * `realtime` (the default) pings the stream's private topic after each batch;
+   * `poll` skips the ping for apps near the Realtime message quota, and readers
+   * poll instead.
    */
   readonly wake?: "realtime" | "poll";
   /** A Supabase client a reader joins the topic with, to wake up on the ping. */
   readonly realtime?: Pick<SupabaseClient, "channel" | "removeChannel">;
   /** `blocks.streams.options.topic`. Defaults to `stream`. */
   readonly topic?: string;
-  /** Milliseconds between reads of an idle stream: 250 by default, 2000 with `realtime`. */
+  /**
+   * Milliseconds between reads of an idle stream: 250 by default, 2000 with
+   * `realtime`.
+   */
   readonly pollMs?: number;
   /** Chunks per read. Defaults to 1000. */
   readonly batch?: number;
@@ -44,21 +50,21 @@ interface TeedStream {
   readonly stream: ReadableStream<string>;
   /**
    * Settles once every chunk is stored and the stream is closed, with the
-   * number of chunks. It keeps going after the live client disconnects, so
-   * hand it to `waitUntil` or `after`.
+   * number of chunks. It keeps going after the live client disconnects, so hand
+   * it to `waitUntil` or `after`.
    */
   readonly persisted: AsyncResult<number>;
 }
 /**
- * Copies `source` into `store` under `id` while passing it through. Chunks
- * are written in batches, each at its own index, so a reader that counted
- * `n` chunks of the live stream resumes with `read(id, n)`.
+ * Copies `source` into `store` under `id` while passing it through. Chunks are
+ * written in batches, each at its own index, so a reader that counted `n`
+ * chunks of the live stream resumes with `read(id, n)`.
  */
 export declare function teeToStore(store: StreamStore, id: string, source: ReadableStream<string>, options?: TeeToStoreOptions): TeedStream;
 /**
  * Stores `source` under `id` without a live copy, for a stream the caller
- * already sends elsewhere (the second branch of its own `tee()`). Settles
- * like `teeToStore`'s `persisted`.
+ * already sends elsewhere (the second branch of its own `tee()`). Settles like
+ * `teeToStore`'s `persisted`.
  */
 export declare function writeToStore(store: StreamStore, id: string, source: ReadableStream<string>, options?: TeeToStoreOptions): AsyncResult<number>;
 interface ResumeFromStoreOptions {
@@ -67,9 +73,9 @@ interface ResumeFromStoreOptions {
   readonly signal?: AbortSignal;
 }
 /**
- * The rest of stream `id` from `fromIdx`, or `undefined` when there is
- * nothing to resume: no such stream, or a closed one the client has read to
- * the end. A route answers `undefined` with 204.
+ * The rest of stream `id` from `fromIdx`, or `undefined` when there is nothing
+ * to resume: no such stream, or a closed one the client has read to the end. A
+ * route answers `undefined` with 204.
  */
 export declare function resumeFromStore(store: StreamStore, id: string, options?: ResumeFromStoreOptions): AsyncResult<ReadableStream<string> | undefined>;
 //#endregion

package/dist/streams/index.js

@@ -1,8 +1,7 @@
 import { n as isRecord } from "../guards-6F2bCtQR.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../block-transport-J7ZepTq2.js";
-import { D as recordOf, F as stringsOf, M as seconds, o as blockCall } from "../block-helpers-DkVZNDrj.js";
-import { n as teeToStore, r as writeToStore, t as resumeFromStore } from "../tee-Cw-iJAWL.js";
-import { t as pollingRead } from "../store-BdH5ruDx.js";
+import { B as dbTransport, D as recordOf, F as stringsOf, H as rpcTransport, M as seconds, U as sqlTransport, o as blockCall } from "../block-helpers-CiKtrb6g.js";
+import { n as teeToStore, r as writeToStore, t as resumeFromStore } from "../tee-DwkUvJD_.js";
+import { t as pollingRead } from "../store-McN-2esd.js";
 //#region src/streams/postgres.ts
 function statusOf(value) {
 	if (!isRecord(value)) return;

package/dist/streams/redis/index.d.ts

@@ -1,8 +1,8 @@
-import { o as StreamStore } from "../../store-B18bIvKc.js";
+import { o as StreamStore } from "../../store-o0HwYXl8.js";
 //#region src/streams/redis/redis.d.ts
 /**
- * The commands the store sends, as node-redis 5 and 6 (`createClient()`)
- * name them. Any client with these methods works.
+ * The commands the store sends, as node-redis 5 and 6 (`createClient()`) name
+ * them. Any client with these methods works.
  */
 interface RedisStreamClient {
   hSetNX(key: string, field: string, value: string): Promise<unknown>;
@@ -24,7 +24,10 @@ interface RedisStreamSharedOptions {
   readonly keyPrefix?: string;
   /** How long a stream opened without a `ttl` lives. Defaults to `'1 day'`. */
   readonly ttl?: number | string;
-  /** Milliseconds between reads of an idle stream: 250 by default, 2000 with `subscriber`. */
+  /**
+   * Milliseconds between reads of an idle stream: 250 by default, 2000 with
+   * `subscriber`.
+   */
   readonly pollMs?: number;
   /** Chunks per read. Defaults to 1000. */
   readonly batch?: number;
@@ -43,9 +46,9 @@ type RedisStreamStoreOptions = RedisStreamSharedOptions & ({
 /**
  * A `StreamStore` on Redis, for apps that keep live output out of Postgres.
  * Chunks live in a list and the state in a hash, both expiring after the
- * stream's `ttl`, so `purge` has nothing to do and resolves with 0. Redis
- * has no row-level security: check that the caller owns the stream before
- * `read` or `cancel`.
+ * stream's `ttl`, so `purge` has nothing to do and resolves with 0. Redis has
+ * no row-level security: check that the caller owns the stream before `read` or
+ * `cancel`.
  */
 export declare function redisStreamStore(options: RedisStreamStoreOptions, load?: () => Promise<unknown>): StreamStore;
 //#endregion

package/dist/streams/redis/index.js

@@ -1,13 +1,13 @@
-import { n as dbError } from "../../errors-BV1SKTVs.js";
-import { a as ok, r as err, t as AsyncResult } from "../../result-DIeYscA3.js";
+import { n as dbError } from "../../errors-03ysrOt4.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-B3m7xtRY.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
-import { t as importOptionalPeer } from "../../optional-peer-Dx8TaYXw.js";
-import { t as pollingRead } from "../../store-BdH5ruDx.js";
+import { t as importOptionalPeer } from "../../optional-peer-C1NbBRJm.js";
+import { t as pollingRead } from "../../store-McN-2esd.js";
 //#region src/streams/redis/redis.ts
 const isNodeRedis = (value) => isRecord(value) && typeof value["createClient"] === "function";
 /**
-* Loads `redis` on first use. The specifier is a variable so bundlers leave
-* the optional peer out of apps that pass their own client.
+* Loads `redis` on first use. The specifier is a variable so bundlers leave the
+* optional peer out of apps that pass their own client.
 */
 const loadRedis = () => importOptionalPeer("redis");
 async function connectUrl(url, load) {
@@ -39,9 +39,9 @@ const text = (value) => typeof value === "string" ? value : void 0;
 /**
 * A `StreamStore` on Redis, for apps that keep live output out of Postgres.
 * Chunks live in a list and the state in a hash, both expiring after the
-* stream's `ttl`, so `purge` has nothing to do and resolves with 0. Redis
-* has no row-level security: check that the caller owns the stream before
-* `read` or `cancel`.
+* stream's `ttl`, so `purge` has nothing to do and resolves with 0. Redis has
+* no row-level security: check that the caller owns the stream before `read` or
+* `cancel`.
 */
 function redisStreamStore(options, load = loadRedis) {
 	let connected = "client" in options ? Promise.resolve({

package/dist/stripe/index.d.ts

@@ -1,6 +1,9 @@
-import { t as StripeClient } from "../stripe-NVcNOhHy.js";
+import { t as StripeClient } from "../stripe-X22LjuH-.js";
 //#region src/stripe/stripe.d.ts
-/** The secret key and, optionally, the API version of the Stripe client to create. */
+/**
+ * The secret key and, optionally, the API version of the Stripe client to
+ * create.
+ */
 interface StripeFromKeyOptions {
   readonly secretKey: string;
   readonly apiVersion?: string;

package/dist/stripe/index.js

@@ -1,5 +1,5 @@
-import { n as memoized } from "../optional-peer-Dx8TaYXw.js";
-import { n as stripeClient } from "../stripe-XZrSmDTf.js";
+import { n as memoized } from "../optional-peer-C1NbBRJm.js";
+import { n as stripeClient } from "../stripe-BJUfp5jM.js";
 //#region src/stripe/stripe.ts
 /**
 * A `stripe` source for the billing, usage and commerce Stripe adapters that

package/dist/stripe-BJUfp5jM.js

@@ -0,0 +1,32 @@
+import { t as importOptionalPeer } from "./optional-peer-C1NbBRJm.js";
+//#region src/blocks/stripe.ts
+const isModule = (value) => typeof value === "object" && value !== null && "default" in value && typeof value.default === "function" && "createFetchHttpClient" in value.default;
+/**
+* Loads `stripe` on first use. The specifier is a variable so bundlers leave
+* the optional peer out of apps that pass their own client; a missing install
+* returns `undefined` and the caller explains how to add it.
+*/
+const loadStripeModule = () => importOptionalPeer("stripe");
+/**
+* The client `source` names: itself, or one created with Stripe's fetch HTTP
+* client so it runs on every WinterTC runtime.
+*/
+async function stripeClient(source, load = loadStripeModule) {
+	if (typeof source === "function") return source();
+	if (!("secretKey" in source)) return source;
+	const loaded = await load();
+	if (!isModule(loaded)) throw new TypeError("Stripe calls need the stripe package in a runtime that can resolve it: pnpm add stripe, and in a bundled app pass `stripe: stripeFromKey({ secretKey })` from better-supabase/stripe, or a Stripe client");
+	const Stripe = loaded.default;
+	return new Stripe(source.secretKey, {
+		httpClient: Stripe.createFetchHttpClient(),
+		...source.apiVersion === void 0 ? {} : { apiVersion: source.apiVersion }
+	});
+}
+/** Resolves the client once, on first use; a function source runs on every use. */
+function lazyStripe(source) {
+	if (typeof source === "function") return async () => source();
+	let client;
+	return () => client ??= stripeClient(source);
+}
+//#endregion
+export { stripeClient as n, lazyStripe as t };

package/dist/stripe-X22LjuH-.d.ts

@@ -0,0 +1,156 @@
+//#region src/blocks/stripe.d.ts
+/**
+ * The part of the Stripe SDK (`stripe`, an optional peer) the billing and usage
+ * blocks call, typed structurally so the blocks never import it.
+ */
+interface StripeClient {
+  readonly customers: {
+    create(params: {
+      readonly email?: string;
+      readonly name?: string;
+      readonly metadata?: Readonly<Record<string, string>>;
+    }, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.updateCustomer`. */
+    update?(id: string, params: Readonly<Record<string, unknown>>): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.taxIds`. */
+    listTaxIds?(id: string, params?: {
+      readonly limit?: number;
+    }): Promise<{
+      readonly data: readonly StripeTaxId[];
+    }>;
+    /** Used by `billing.addTaxId`. */
+    createTaxId?(id: string, params: {
+      readonly type: string;
+      readonly value: string;
+    }): Promise<StripeTaxId>;
+    /** Used by `billing.removeTaxId`. */
+    deleteTaxId?(id: string, taxId: string): Promise<{
+      readonly id: string;
+      readonly deleted?: boolean;
+    }>;
+  };
+  readonly checkout: {
+    readonly sessions: {
+      create(params: Readonly<Record<string, unknown>>, options?: {
+        readonly idempotencyKey?: string;
+      }): Promise<{
+        readonly id: string;
+        readonly url: string | null;
+      }>;
+    };
+  };
+  readonly billingPortal: {
+    readonly sessions: {
+      create(params: {
+        readonly customer?: string;
+        readonly customer_account?: string;
+        readonly return_url?: string;
+      }): Promise<{
+        readonly id: string;
+        readonly url: string;
+      }>;
+    };
+  };
+  readonly subscriptionItems: {
+    update(id: string, params: {
+      readonly quantity: number;
+      readonly proration_behavior?: string;
+    }, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+      readonly quantity?: number | null;
+    }>;
+  };
+  readonly subscriptions: {
+    cancel(id: string): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.changePlan` and `billing.cancelAtPeriodEnd`. */
+    update?(id: string, params: Readonly<Record<string, unknown>>, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+    }>;
+  };
+  /** Used by `billing.voidInvoice` and `billing.markInvoiceUncollectible`. */
+  readonly invoices?: {
+    voidInvoice(id: string): Promise<{
+      readonly id: string;
+      readonly status?: string | null;
+    }>;
+    markUncollectible(id: string): Promise<{
+      readonly id: string;
+      readonly status?: string | null;
+    }>;
+  };
+  readonly billing: {
+    readonly meterEvents: {
+      create(params: {
+        readonly event_name: string;
+        readonly payload: Readonly<Record<string, string>>;
+        readonly identifier?: string;
+        readonly timestamp?: number;
+      }, options?: {
+        readonly idempotencyKey?: string;
+      }): Promise<unknown>;
+    };
+  };
+  /**
+   * Stripe's v2 API. `billing` with `customerAccounts` creates the tenant's
+   * Accounts v2 account through it.
+   */
+  readonly v2?: {
+    readonly core: {
+      readonly accounts: {
+        create(params: Readonly<Record<string, unknown>>, options?: {
+          readonly idempotencyKey?: string;
+        }): Promise<{
+          readonly id: string;
+        }>;
+      };
+    };
+  };
+  readonly webhooks: {
+    constructEventAsync(payload: string, header: string, secret: string): Promise<{
+      readonly id: string;
+      readonly type: string;
+      readonly data: {
+        readonly object: unknown;
+      };
+    }>;
+  };
+}
+/** A customer tax id as Stripe returns it (`eu_vat`, `DE123456789`). */
+interface StripeTaxId {
+  readonly id: string;
+  readonly type: string;
+  readonly value: string;
+  readonly country?: string | null;
+  readonly verification?: {
+    readonly status?: string | null;
+  } | null;
+  readonly created?: number | null;
+}
+/**
+ * A Stripe client, a function that returns a client (`stripeFromKey()` from
+ * `better-supabase/stripe` in a bundled app), or the secret key to create one
+ * from the `stripe` package: the plain Node shortcut, which needs a runtime
+ * that resolves `stripe` when the call runs. The function runs on every Stripe
+ * call, so it can create the client lazily, pick a per-request or per-tenant
+ * client (Stripe Connect), or read a rotated key; cache inside it when needed.
+ * `C` is the part of the SDK the caller uses (`StripeClient` for billing and
+ * usage).
+ */
+type StripeSource<C extends object = StripeClient> = C | {
+  readonly secretKey: string;
+  readonly apiVersion?: string;
+} | (() => C | Promise<C>);
+//#endregion
+export { StripeSource as n, StripeTaxId as r, StripeClient as t };

package/dist/subject-readers-CsTpx44c.js

@@ -0,0 +1,49 @@
+import "./block-helpers-CiKtrb6g.js";
+//#region src/core/subject-readers.ts
+/**
+* A registered subject's type and id, from `subjects/<type>/<id>` or
+* `<type>/<id>`.
+*/
+function parseSubject(subject, types) {
+	const rest = subject.startsWith("subjects/") ? subject.slice(9) : subject;
+	const slash = rest.indexOf("/");
+	if (slash <= 0 || slash === rest.length - 1) return;
+	const type = rest.slice(0, slash);
+	return types.has(type) ? {
+		type,
+		id: rest.slice(slash + 1)
+	} : void 0;
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* The default subscriber policy under an authorization provider: a subscriber
+* gets an event about a subject in `config.subjects` only when
+* `can_subject_for` says it may `read` the subject (the key in
+* `config.subjects.<type>.permissions`, never a share-link grant). Events
+* without a subject, or about a type the registry doesn't list, keep every
+* subscriber, so the block's own tenant check decides them. `transport` must
+* run as the service role.
+*/
+function subjectReaders(transport, options = {}) {
+	const schema = options.schema ?? "better_supabase";
+	const action = options.action ?? "read";
+	let types;
+	const registered = () => types ??= transport.call(schema, "subject_types", {}).then((value) => new Set(Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [])).catch((cause) => {
+		types = void 0;
+		throw cause;
+	});
+	return async (event, subscribers) => {
+		if (typeof event.subject !== "string" || subscribers.length === 0) return subscribers;
+		const subject = parseSubject(event.subject, await registered());
+		if (subject === void 0) return subscribers;
+		const allowed = await Promise.all(subscribers.map(async (subscriber) => UUID.test(subscriber.principal) ? await transport.call(schema, "can_subject_for", {
+			member: subscriber.principal,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			action
+		}) === true : false));
+		return subscribers.filter((_, index) => allowed[index]);
+	};
+}
+//#endregion
+export { subjectReaders as t };

package/dist/subject-readers-DEZ45DQF.d.ts

@@ -0,0 +1,21 @@
+import { t as BlockTransport } from "./block-transport-d53POsem.js";
+import { g as SubscriberPolicy } from "./authorization-hooks-dLmUO_PZ.js";
+//#region src/core/subject-readers.d.ts
+interface SubjectReadersOptions {
+  /** The schema of the `subjects` module. Default `better_supabase`. */
+  readonly schema?: string;
+  /** The `config.subjects` action to check. Default `read`. */
+  readonly action?: string;
+}
+/**
+ * The default subscriber policy under an authorization provider: a subscriber
+ * gets an event about a subject in `config.subjects` only when
+ * `can_subject_for` says it may `read` the subject (the key in
+ * `config.subjects.<type>.permissions`, never a share-link grant). Events
+ * without a subject, or about a type the registry doesn't list, keep every
+ * subscriber, so the block's own tenant check decides them. `transport` must
+ * run as the service role.
+ */
+declare function subjectReaders(transport: BlockTransport, options?: SubjectReadersOptions): SubscriberPolicy;
+//#endregion
+export { subjectReaders as n, SubjectReadersOptions as t };

package/dist/subjects-B6p4oAZJ.d.ts

@@ -0,0 +1,78 @@
+//#region src/config/types/subjects.d.ts
+/**
+ * One entity the app's blocks attach to (`subjects.<type>`): a task, a
+ * customer, a document. Every subject-bound SQL module reads these entries
+ * unless its own `options.subjects` says otherwise. ADR 0020.
+ */
+interface SubjectConfig {
+  /** `schema.table`, or a table in `public`. */
+  readonly table: string;
+  /** The id column. Defaults to `id`. */
+  readonly id?: string;
+  /**
+   * The id column's type, such as `uuid` or `bigint`, so lookups compare on the
+   * primary key's own type. Without it the column is compared as text.
+   */
+  readonly idType?: string;
+  /**
+   * The tenant column. Defaults to `organization_id`, or
+   * `<blocks.tenant.entities.organization>_id` when the tenant is renamed.
+   * `false` for a subject without a tenant, which modules that keep a tenant on
+   * every row skip.
+   */
+  readonly tenant?: string | false;
+  /** The column `subject_title` returns. */
+  readonly title?: string;
+  /**
+   * The path `subject_url` returns, with `{column}` placeholders:
+   * `/tasks/{id}`.
+   */
+  readonly url?: string;
+  /**
+   * A permission key per action (`read`, `write`, or an app action) that
+   * `can_subject` checks in the subject's tenant, on top of the row being
+   * visible to the caller. `read` is also the permission modules check before
+   * they attach rows to the subject.
+   */
+  readonly permissions?: Readonly<Record<string, string>>;
+  /**
+   * A scope the authorization provider declares whose ids are this subject's
+   * ids, so a grant on the record counts as well as one on the tenant.
+   */
+  readonly scope?: string;
+  /** Delete module rows for a subject when its row is deleted. */
+  readonly cascade?: boolean;
+  /**
+   * The column holding the soft-delete time. Blocks hide rows where it is set,
+   * metrics skip them, and `gen` makes it the table's `softDelete()` column.
+   */
+  readonly deletedAt?: string;
+  /** The columns a search index reads. */
+  readonly search?: {
+    readonly title?: string;
+    readonly body?: readonly string[];
+  };
+  /**
+   * The text column holding the subject's rank key, and the column it is
+   * grouped by (a board stage), for `move()`. ADR 0021.
+   */
+  readonly rank?: {
+    readonly column: string;
+    readonly group?: string;
+  };
+  /**
+   * The columns the versions block snapshots and restores, and whether it
+   * snapshots on each change. An app table's `subject.versions` sets it.
+   */
+  readonly versions?: {
+    readonly columns: readonly string[];
+    readonly auto: boolean;
+  };
+}
+/**
+ * The app's subject types, keyed by type name (lowercase, digits and
+ * underscores).
+ */
+type SubjectsConfig = Readonly<Record<string, SubjectConfig>>;
+//#endregion
+export { SubjectsConfig as n, SubjectConfig as t };

package/dist/subjects-DXFmanh5.d.ts

@@ -0,0 +1,90 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "./result-C6jDfedy.js";
+import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-BaugZlJV.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+//#region src/blocks/subjects/my-work-kinds.d.ts
+/** What a `my_work` item waits on. */
+type MyWorkKind = "assigned" | "approval" | "reminder" | "mention" | "sla";
+/** The kinds `my_work` returns, in the order the docs list them. */
+declare const MY_WORK_KINDS: readonly MyWorkKind[];
+//#endregion
+//#region src/blocks/subjects/subjects.d.ts
+/** The most refs one `subject_titles` call takes; `resolve` splits above it. */
+declare const SUBJECT_TITLES_LIMIT = 500;
+interface SubjectsOptions extends BlockOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Subjects>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A subject with its title and path, from `config.subjects`. */
+interface ResolvedSubject extends SubjectRef {
+  /** The `title` column's value, when the type names one. */
+  readonly title?: string;
+  /** The `url` template filled in, such as `/customers/42`. */
+  readonly url?: string;
+}
+/** A record page's header and tab badges, from `record_summary`. */
+interface RecordSummary extends ResolvedSubject {
+  /** Rows per section the caller can read, for each installed section asked. */
+  readonly counts: Readonly<Record<string, number>>;
+  /** Per section, whether a row is newer than `seenAt`. */
+  readonly unread: Readonly<Record<string, boolean>>;
+}
+interface RecordSummaryOptions {
+  /** When the caller last saw the record; every section is read without it. */
+  readonly seenAt?: Temporal.Instant | null;
+}
+/** One thing waiting on the caller, from `my_work`. */
+interface MyWorkItem {
+  readonly kind: MyWorkKind;
+  /** The record it is about: the work item, or the approval's subject. */
+  readonly subject: SubjectRef;
+  /**
+   * The row that put it here: the work item, approval request, reminder,
+   * comment or SLA clock id.
+   */
+  readonly ref: string;
+  readonly title?: string;
+  readonly url?: string;
+  /** The due date, or when it arrived. */
+  readonly at?: Temporal.Instant;
+}
+/** The most items one `my_work` call returns. */
+declare const MY_WORK_LIMIT = 200;
+interface MyWorkOptions {
+  /** Only this organization's work. Default: every organization. */
+  readonly tenant?: string;
+  /** At most this many items, newest first. Default 50, at most 200. */
+  readonly pageSize?: number;
+}
+/** The subjects block's registry as typed calls. */
+interface Subjects {
+  /**
+   * Titles and paths for many subjects in one call, keyed by `subjectKey`
+   * (`type:id`). A subject the caller can't read, a soft-deleted row or an
+   * unknown type is left out.
+   */
+  resolve(refs: readonly SubjectRef[]): AsyncResult<Readonly<Record<string, ResolvedSubject>>>;
+  /**
+   * The subject's title and path with a count and unread state for each of
+   * `sections` (`comments`, `attachments`), in one round trip; `undefined` when
+   * the caller can't read the subject.
+   */
+  summary(subject: SubjectRef, sections: readonly string[], options?: RecordSummaryOptions): AsyncResult<RecordSummary | undefined>;
+  /**
+   * What waits on the caller across the installed blocks, newest first: open
+   * work items assigned to them, approvals they can decide, their reminders
+   * sent this week, recent mentions and SLA clocks warned on their work.
+   */
+  myWork(options?: MyWorkOptions): AsyncResult<readonly MyWorkItem[]>;
+}
+/**
+ * The `subjects` module's `subject_titles` as a typed call, for lists and
+ * mentions that show a link to each subject.
+ */
+declare function createSubjects(options: SubjectsOptions): Subjects;
+//#endregion
+export { RecordSummaryOptions as a, Subjects as c, MY_WORK_KINDS as d, MyWorkKind as f, RecordSummary as i, SubjectsOptions as l, MyWorkItem as n, ResolvedSubject as o, MyWorkOptions as r, SUBJECT_TITLES_LIMIT as s, MY_WORK_LIMIT as t, createSubjects as u };