better-supabase 0.13.0 → 0.14.0

package/dist/ai-sdk/memory/index.js

@@ -1,4 +1,4 @@
-import { t as DbException } from "../../db-exception-CnWcYPxL.js";
+import { t as DbException } from "../../db-exception-Lngc1W49.js";
 import { t as SPEC_PINS } from "../../spec-pins-D3Tm6HJi.js";
 import { Output, generateText, jsonSchema, tool } from "ai";
 //#region src/ai-sdk/memory/memory.ts

package/dist/ai-sdk/workflow/index.d.ts

@@ -1,9 +1,9 @@
 import { i as AiMessage } from "../../message-Bg4TKA12.js";
-import { A as AiStoredMessageStatus, E as AiRunStatus, i as AiChat } from "../../ai-chat-B00sIOjY.js";
+import { A as AiStoredMessageStatus, E as AiRunStatus, i as AiChat } from "../../ai-chat-DBxEz3o1.js";
 import { n as GatewayOptions } from "../../gateway-options-BlVCqgb8.js";
-import { o as StreamStore } from "../../store-DKqbuNvw.js";
-import { i as CostBackfillPayload, t as AiUsage } from "../../gateway-Dar9C0uP.js";
-import { n as AssistantContext, t as Assistant } from "../../assistant-CcP_kpu7.js";
+import { o as StreamStore } from "../../store-o0HwYXl8.js";
+import { i as CostBackfillPayload, t as AiUsage } from "../../gateway-DI8dbOml.js";
+import { n as AssistantContext, t as Assistant } from "../../assistant-D1yev_fR.js";
 import { r as ModelSource } from "../../model-messages-DrR4lZ_c.js";
 import { LanguageModelUsage, ModelMessage } from "ai";
 import { ModelCallStreamPart } from "@ai-sdk/workflow";

package/dist/ai-sdk/workflow/index.js

@@ -1,10 +1,10 @@
-import { n as dbError } from "../../errors-D7u24ZJH.js";
+import { n as dbError } from "../../errors-03ysrOt4.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
-import { o as problemResponse } from "../../problem-D0KDiYPk.js";
-import { f as runRelease, m as usageOf, o as toUIMessage, t as AI_SDK_UI_FORMAT } from "../../messages-Bd5-5ZjP.js";
-import { t as fromModelMessages } from "../../model-messages-BWyXXA4s.js";
-import { n as teeToStore, t as resumeFromStore } from "../../tee-1fsH3bEz.js";
-import { n as readJson, r as sse, t as badRequest } from "../../http-AkLjqOuB.js";
+import { o as problemResponse } from "../../problem-BWElIgIb.js";
+import { f as runRelease, m as usageOf, o as toUIMessage, t as AI_SDK_UI_FORMAT } from "../../messages-DNzIVvgN.js";
+import { t as fromModelMessages } from "../../model-messages-D-jVOIOK.js";
+import { n as teeToStore, t as resumeFromStore } from "../../tee-DwkUvJD_.js";
+import { n as readJson, r as sse, t as badRequest } from "../../http-51t9xppD.js";
 import { t as WORKFLOW_ATTRIBUTES } from "../../attributes-BOFl922R.js";
 import { JsonToSseTransformStream } from "ai";
 import { createModelCallToUIChunkTransform, normalizeUIMessageStreamParts } from "@ai-sdk/workflow";

package/dist/ai-tasks-BDywBUgN.d.ts

@@ -0,0 +1,166 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
+import { 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";
+import { g as JobHandler } from "./types-CGUDoF5I.js";
+import { r as RunState } from "./run-state-CPo-1X2B.js";
+import { _ as Notifier } from "./define-block-COpcS6aT.js";
+//#region src/blocks/ai-tasks/ai-tasks.d.ts
+/** A task run's state, in the words ai-chat and workflow runs share. */
+type AiTaskRunStatus = Extract<RunState, "queued" | "running" | "completed" | "failed">;
+interface AiTaskRun {
+  readonly id: string;
+  readonly taskId: string;
+  readonly organizationId: string;
+  readonly userId: string;
+  readonly status: AiTaskRunStatus;
+  readonly scheduledFor: Temporal.Instant;
+  readonly chatId: string | undefined;
+  readonly error: string | undefined;
+  readonly startedAt: Temporal.Instant | undefined;
+  readonly finishedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+interface AiTask {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly userId: string;
+  /** The chat each run writes to; the first run's chat when unset. */
+  readonly chatId: string | undefined;
+  readonly agentId: string | undefined;
+  readonly title: string;
+  readonly prompt: string;
+  /** Five-field cron or an interval such as `30 minutes`. */
+  readonly cron: string;
+  /** An IANA time zone the cron runs in. */
+  readonly timezone: string;
+  readonly enabled: boolean;
+  readonly nextRunAt: Temporal.Instant | undefined;
+  readonly lastRunAt: Temporal.Instant | undefined;
+  /** Only `list` sets it. */
+  readonly lastRun: AiTaskRun | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface AiTaskFields {
+  readonly title?: string;
+  readonly prompt?: string;
+  readonly cron?: string;
+  readonly timezone?: string;
+  readonly chatId?: string | null;
+  readonly agentId?: string | null;
+}
+type NewAiTask = AiTaskFields & {
+  readonly title: string;
+  readonly prompt: string;
+  readonly cron: string;
+};
+/**
+ * Runs one occurrence of a task, as the task's user: sends the prompt to the
+ * assistant and returns the chat it wrote to. A throw fails the run.
+ */
+type AiTaskRunner = ((task: AiTask, run: AiTaskRun, signal: AbortSignal) => Promise<{
+  readonly chatId?: string;
+} | void>) & {
+  /** The runner contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+};
+interface AiTaskOutcome {
+  readonly task: AiTask;
+  readonly run: AiTaskRun;
+  readonly ok: boolean;
+  readonly error?: string;
+  readonly chatId?: string;
+}
+interface AiTasksOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  /**
+   * A Standard Schema for the task columns the app adds
+   * (`blocks.ai-tasks.options.extraColumns`), keyed by column name. It types
+   * and parses them on `create`, `update`, `pause`, `resume` and `list`, and
+   * validates them on `create` and `update`, which return a `validation` error
+   * for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<AiTasks<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  /** Calls as the user: `rpcTransport(supabase)`. */
+  readonly transport: BlockTransport;
+  /** Calls as the service role, for `tick`, `execute` and `runJob`. */
+  readonly service?: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`. Default `better_supabase`.
+   */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  readonly run?: AiTaskRunner;
+  /**
+   * Called after each run finishes, to notify the task's user. Defaults to
+   * `notification` through `notifier`.
+   */
+  readonly notify?: (outcome: AiTaskOutcome) => unknown;
+  /** The `notifier` port: the `notifications` block, from `createBlocks`. */
+  readonly notifier?: Notifier;
+  /**
+   * The notification type `notifier` sends the task's user after each run. Its
+   * data is `{ taskId, runId, ok, error?, chatId? }`.
+   */
+  readonly notification?: string;
+  /** The clock, for tests. */
+  readonly now?: () => Temporal.Instant;
+}
+/** `F` is the extra task fields `options.fields` describes. */
+interface AiTasks<F extends object = Record<never, never>> {
+  /** Keys besides the task's own are its extra columns. */
+  create(organizationId: string, task: NewAiTask & Partial<F>): AsyncResult<AiTask & F>;
+  update(organizationId: string, taskId: string, fields: AiTaskFields & Partial<F>): AsyncResult<AiTask & F>;
+  pause(organizationId: string, taskId: string): AsyncResult<AiTask & F>;
+  /** Enables a task again; it runs at its next occurrence. */
+  resume(organizationId: string, taskId: string): AsyncResult<AiTask & F>;
+  remove(taskId: string): AsyncResult<boolean>;
+  /** The caller's tasks, or every task in the tenant with `all` and `ai.admin`. */
+  list(organizationId: string, options?: {
+    readonly all?: boolean;
+  }): AsyncResult<readonly (AiTask & F)[]>;
+  runs(taskId: string, options?: {
+    readonly limit?: number;
+  }): AsyncResult<readonly AiTaskRun[]>;
+  /**
+   * Claims due tasks (service role): queues a run for each, which the
+   * `ai_task_run` queue picks up when jobs is installed, and computes the next
+   * occurrence of every task that needs one. Returns the queued runs.
+   */
+  tick(options?: {
+    readonly batch?: number;
+  }): AsyncResult<readonly AiTaskRun[]>;
+  /**
+   * Starts, runs and finishes a queued run (service role). `false` when another
+   * worker has it.
+   */
+  execute(runId: string, options?: {
+    readonly signal?: AbortSignal;
+  }): AsyncResult<boolean>;
+  /** The handler for the `ai_task_run` queue. */
+  runJob(): JobHandler<{
+    readonly run_id: string;
+  }>;
+  /**
+   * `tick` then `execute` each run in turn, without a queue. Returns how many
+   * ran. A failed run does not stop the others; when any failed, the result is
+   * the first error, with every failed run listed in `details`.
+   */
+  drain(options?: {
+    readonly batch?: number;
+    readonly signal?: AbortSignal;
+  }): AsyncResult<number>;
+}
+/** Prompts users schedule on a cron, and the scheduler that runs them. */
+declare function createAiTasks<S extends StandardSchemaV1 | undefined = undefined>(options: AiTasksOptions<S>): AiTasks<FieldsOf<S>>;
+//#endregion
+export { AiTaskRunStatus as a, AiTasksOptions as c, AiTaskRun as i, NewAiTask as l, AiTaskFields as n, AiTaskRunner as o, AiTaskOutcome as r, AiTasks as s, AiTask as t, createAiTasks as u };

package/dist/anchors-7F34QyHa.d.ts

@@ -0,0 +1,40 @@
+//#region src/blocks/messaging/rows.d.ts
+/** The private Realtime topic of a conversation's message pings. */
+declare function conversationTopic(conversationId: string, topic?: string): string;
+//#endregion
+//#region src/blocks/messaging/anchors.d.ts
+/** A box as fractions of the page or frame, measured from its top-left corner. */
+interface AnchorRegion {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+/** Where on a file a message points: a page, a region, a moment or a span. */
+interface FileAnchorAt {
+  /** The page, from 1. */
+  readonly page?: number;
+  /** A box on the page or the video frame, inside 0 to 1. */
+  readonly region?: AnchorRegion;
+  /** Seconds from the start of an audio or video file. */
+  readonly start?: number;
+  /** Seconds, after `start`: the end of a span. */
+  readonly end?: number;
+}
+/**
+ * A message's anchor on an attachment of its record or conversation.
+ * `send_message` checks its shape and that the file is on the same record.
+ */
+interface FileAnchor extends FileAnchorAt {
+  readonly kind: "file";
+  readonly attachmentId: string;
+}
+/** Whether `value` is a file anchor `send_message` accepts. */
+declare function isFileAnchor(value: unknown): value is FileAnchor;
+/**
+ * An anchor on an attachment, for `anchor` on a new message or comment. Throws
+ * a `TypeError` when the page, region or span is out of range.
+ */
+declare function fileAnchor(attachmentId: string, at?: FileAnchorAt): FileAnchor;
+//#endregion
+export { isFileAnchor as a, fileAnchor as i, FileAnchor as n, conversationTopic as o, FileAnchorAt as r, AnchorRegion as t };

package/dist/announcements-BeOD0zbc.js

@@ -0,0 +1,128 @@
+import { t as AsyncResult } from "./result-B3m7xtRY.js";
+import { C as optionalText, D as recordOf, F as stringsOf, I as textOf, R as toInstant, S as optionalInstant, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "./block-helpers-CiKtrb6g.js";
+import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
+import { c as withFields, i as extraOf, n as blockFields, t as allWithFields } from "./block-fields-DBSJSeaO.js";
+//#region src/blocks/announcements/announcements.ts
+const SEVERITIES = /* @__PURE__ */ new Set([
+	"info",
+	"success",
+	"warning",
+	"critical"
+]);
+function severityOf(value) {
+	const text = textOf(value);
+	return SEVERITIES.has(text) ? text : "info";
+}
+function announcementOf(value) {
+	const row = recordOf(value, "announcements");
+	return {
+		id: textOf(row["id"]),
+		title: textOf(row["title"]),
+		body: textOf(row["body"] ?? ""),
+		severity: severityOf(row["severity"]),
+		href: optionalText(row["href"]),
+		startsAt: toInstant(textOf(row["starts_at"])),
+		endsAt: optionalInstant(row["ends_at"]),
+		dismissible: row["dismissible"] !== false,
+		createdAt: toInstant(textOf(row["created_at"])),
+		updatedAt: toInstant(textOf(row["updated_at"]))
+	};
+}
+function audienceOf(type, targets) {
+	const values = stringsOf(targets);
+	switch (type) {
+		case "tenant": return {
+			type,
+			organizationIds: values
+		};
+		case "role": return {
+			type,
+			roles: values
+		};
+		case "plan": return {
+			type,
+			plans: values
+		};
+		default: return { type: "all" };
+	}
+}
+function managedOf(value) {
+	const row = recordOf(value, "announcements");
+	return {
+		...announcementOf(row),
+		audience: audienceOf(row["audience"], row["targets"]),
+		createdBy: optionalText(row["created_by"])
+	};
+}
+function audienceFields(audience) {
+	switch (audience.type) {
+		case "all": return {
+			audience: "all",
+			targets: []
+		};
+		case "tenant": return {
+			audience: "tenant",
+			targets: audience.organizationIds
+		};
+		case "role": return {
+			audience: "role",
+			targets: audience.roles
+		};
+		case "plan": return {
+			audience: "plan",
+			targets: audience.plans
+		};
+		default: throw new TypeError(`Unknown audience ${JSON.stringify(audience)}`);
+	}
+}
+/** The columns `save_announcement` sets, from the fields the input names. */
+function fieldsOf(input) {
+	const fields = {};
+	if (input.title !== void 0) fields["title"] = input.title;
+	if (input.body !== void 0) fields["body"] = input.body;
+	if (input.severity !== void 0) fields["severity"] = input.severity;
+	if (input.href !== void 0) fields["href"] = input.href;
+	if (input.audience !== void 0) Object.assign(fields, audienceFields(input.audience));
+	if (input.startsAt !== void 0) fields["starts_at"] = instantArg(input.startsAt);
+	if (input.endsAt !== void 0) fields["ends_at"] = instantArg(input.endsAt);
+	if (input.dismissible !== void 0) fields["dismissible"] = input.dismissible;
+	return fields;
+}
+const INPUT_KEYS = /* @__PURE__ */ new Set([
+	"title",
+	"body",
+	"severity",
+	"href",
+	"audience",
+	"startsAt",
+	"endsAt",
+	"dismissible"
+]);
+function createAnnouncements(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "announcement fields");
+	const save = (id, input) => {
+		const columns = fieldsOf(input);
+		return AsyncResult.from(() => fields.write(extraOf(input, INPUT_KEYS))).andThen((extra) => call("save_announcement", {
+			id,
+			fields: {
+				...extra,
+				...columns
+			}
+		}, (value) => value)).andThen((value) => withFields(fields, value, managedOf(value)));
+	};
+	return withBlockHooks({
+		listActive: (organizationId) => call("active_announcements", { tenant: organizationId ?? null }, (value) => recordsOf(value, "active_announcements").map((raw) => [raw, announcementOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
+		dismiss: (announcementId) => call("dismiss_announcement", { id: announcementId }, (value) => value === true),
+		list: () => call("list_announcements", {}, (value) => recordsOf(value, "list_announcements").map((raw) => [raw, managedOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
+		publish: (input) => save(null, input),
+		update: (announcementId, input) => save(announcementId, input),
+		remove: (announcementId) => call("delete_announcement", { id: announcementId }, (value) => value === true)
+	}, options.hooks, {
+		block: "announcements",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+export { createAnnouncements as t };

package/dist/api-CWhpq24a.d.ts

@@ -0,0 +1,174 @@
+import { t as SPEC_PINS } from "./spec-pins-CZ2CL8YZ.js";
+import { t as ApiModel } from "./model-Btl8X9cs.js";
+import { c as SpecDiagnostic, i as DocumentOf, l as VersionOf, s as RenderedOf, t as AnyDocumentFormat } from "./format-AYHceC2m.js";
+import { n as ApiSource, t as ApiOptions } from "./options-Dm-2crCx.js";
+//#region src/openapi/types.d.ts
+type Json = Record<string, unknown>;
+/**
+ * The OpenAPI versions `openapiFormat` renders. `3.3-preview` follows the
+ * v3.3-dev branch.
+ */
+type OpenApiVersion = "3.0" | "3.1" | "3.2" | "3.3-preview";
+/** The `openapi` field `3.3-preview` emits, as in the v3.3-dev branch. */
+declare const OPENAPI_33_PREVIEW_VERSION = "3.3.0";
+interface OpenApiInfo {
+  readonly title: string;
+  readonly version: string;
+  /** OpenAPI 3.1 and later. */
+  readonly summary?: string;
+  readonly description?: string;
+  readonly termsOfService?: string;
+  readonly contact?: {
+    readonly name?: string;
+    readonly url?: string;
+    readonly email?: string;
+  };
+  readonly license?: {
+    readonly name: string;
+    /** OpenAPI 3.1 and later. */
+    readonly identifier?: string;
+    readonly url?: string;
+  };
+}
+type OpenApiSecurityRequirement = Readonly<Record<string, readonly string[]>>;
+type OpenApiComponents = {
+  readonly schemas: Readonly<Record<string, Json>>;
+  readonly responses: Readonly<Record<string, Json>>;
+  readonly securitySchemes: Readonly<Record<string, Json>>;
+};
+interface OpenApiDocumentBase {
+  readonly info: OpenApiInfo;
+  readonly servers?: readonly Json[];
+  readonly tags: readonly Json[];
+  /** Path templates to Path Item objects. */
+  readonly paths: Readonly<Record<string, Json>>;
+  readonly components: OpenApiComponents;
+  readonly security: readonly OpenApiSecurityRequirement[];
+  readonly [extension: `x-${string}`]: unknown;
+}
+/** OpenAPI 3.0 (legacy): schemas use `nullable` and `example`, no webhooks. */
+interface OpenApi30Document extends OpenApiDocumentBase {
+  readonly openapi: typeof SPEC_PINS.openapi30;
+}
+/** OpenAPI 3.1: 3.2 fields travel as the registered `x-oai-*` extensions. */
+interface OpenApi31Document extends OpenApiDocumentBase {
+  readonly openapi: typeof SPEC_PINS.openapi31;
+  readonly jsonSchemaDialect: string;
+  readonly webhooks?: Readonly<Record<string, Json>>;
+}
+/**
+ * OpenAPI 3.2: native `$self`, nested tags, `itemSchema`, `oauth2MetadataUrl`
+ * and `query`.
+ */
+interface OpenApi32Document extends OpenApiDocumentBase {
+  readonly openapi: typeof SPEC_PINS.openapi32;
+  readonly $self?: string;
+  readonly jsonSchemaDialect: string;
+  readonly webhooks?: Readonly<Record<string, Json>>;
+}
+/**
+ * The 3.3 draft: 3.2 plus Path Item `security` and the Security Profiles
+ * proposal.
+ */
+interface OpenApi33PreviewDocument extends OpenApiDocumentBase {
+  readonly openapi: typeof OPENAPI_33_PREVIEW_VERSION;
+  readonly $self?: string;
+  readonly jsonSchemaDialect: string;
+  readonly webhooks?: Readonly<Record<string, Json>>;
+  readonly components: OpenApiComponents & {
+    readonly securityProfileRequirements?: Readonly<Record<string, Json>>;
+  };
+}
+interface OpenApiDocuments {
+  readonly "3.0": OpenApi30Document;
+  readonly "3.1": OpenApi31Document;
+  readonly "3.2": OpenApi32Document;
+  readonly "3.3-preview": OpenApi33PreviewDocument;
+}
+/** An OpenAPI document of one version; 3.1 by default. */
+type OpenApiDocument<V extends OpenApiVersion = "3.1"> = OpenApiDocuments[V];
+type AnyOpenApiDocument = OpenApiDocuments[OpenApiVersion];
+/** What an OpenAPI `transform` receives, discriminated by `version`. */
+type RenderedOpenApi = { readonly [V in OpenApiVersion]: {
+  readonly format: "openapi";
+  readonly version: V;
+  readonly document: OpenApiDocuments[V];
+}; }[OpenApiVersion];
+//#endregion
+//#region src/spec/api.d.ts
+/**
+ * Applies Overlay documents in order to a rendered document and reports what it
+ * found. `better-supabase/overlay` provides one: `(doc, overlays) =>
+ * applyOverlays(doc, overlays, { jsonpath })`.
+ */
+type OverlayEngine = (document: unknown, overlays: readonly unknown[]) => {
+  readonly document: unknown;
+  readonly diagnostics?: readonly SpecDiagnostic[];
+};
+interface RenderOptions<F extends AnyDocumentFormat> {
+  /** Defaults to the format's default version. */
+  readonly version?: VersionOf<F>;
+  /**
+   * Last change to the lowered document, before overlays. It receives a copy,
+   * typed per version; return a replacement or change it in place.
+   */
+  readonly transform?: (rendered: RenderedOf<F>) => DocumentOf<F> | undefined;
+  readonly overlays?: readonly unknown[];
+  /** Overrides the API's `applyOverlays`. */
+  readonly applyOverlays?: OverlayEngine;
+}
+interface RenderResult<F extends AnyDocumentFormat> {
+  readonly format: F["id"];
+  readonly version: VersionOf<F>;
+  readonly document: DocumentOf<F>;
+  /** Building, lowering, overlay and lint findings, without duplicates. */
+  readonly diagnostics: readonly SpecDiagnostic[];
+  readonly fileName: string;
+}
+interface OpenApiRenderOptions<V extends OpenApiVersion> {
+  readonly version?: V;
+  readonly transform?: (rendered: Extract<RenderedOpenApi, {
+    readonly version: V;
+  }>) => OpenApiDocuments[OpenApiVersion] | undefined;
+  readonly overlays?: readonly unknown[];
+  readonly applyOverlays?: OverlayEngine;
+}
+interface OpenApiRenderResult<V extends OpenApiVersion> {
+  readonly format: "openapi";
+  readonly version: V;
+  readonly document: OpenApiDocuments[V];
+  readonly diagnostics: readonly SpecDiagnostic[];
+  readonly fileName: string;
+}
+interface DefineApiOptions<Ref = string> extends ApiOptions<Ref> {
+  /** The default overlay engine for `overlays` in `render`. */
+  readonly applyOverlays?: OverlayEngine;
+}
+interface Api {
+  readonly model: ApiModel;
+  /** Findings while building the model. */
+  readonly diagnostics: readonly SpecDiagnostic[];
+  /**
+   * Lowers the model to a version of any `DocumentFormat`, then runs
+   * `transform`, overlays and the format's lint.
+   */
+  render<F extends AnyDocumentFormat>(format: F, options?: RenderOptions<F>): RenderResult<F>;
+  /** `render(openapiFormat, options)`, typed per version. Defaults to 3.1. */
+  openapi<V extends OpenApiVersion = "3.1">(options?: OpenApiRenderOptions<V>): OpenApiRenderResult<V>;
+}
+/**
+ * The API model for a `defineSupabase()` result, and the documents it renders.
+ * The model is built once per options object; each format and version is
+ * lowered once and copied for every render.
+ *
+ * ```ts
+ * const api = defineApi(betterSupabase, {
+ *   info: { title: "CRM API", version: "1.0.0" },
+ *   resources: { customers: { list: customerList } },
+ * });
+ * const { document } = api.openapi({ version: "3.2" });
+ * ```
+ */
+declare function defineApi<Ref = string>(source: ApiSource, options: DefineApiOptions<Ref>): Api;
+//#endregion
+export { OpenApiDocuments as _, OverlayEngine as a, OpenApiVersion as b, defineApi as c, OpenApi30Document as d, OpenApi31Document as f, OpenApiDocument as g, OpenApiComponents as h, OpenApiRenderResult as i, AnyOpenApiDocument as l, OpenApi33PreviewDocument as m, DefineApiOptions as n, RenderOptions as o, OpenApi32Document as p, OpenApiRenderOptions as r, RenderResult as s, Api as t, OPENAPI_33_PREVIEW_VERSION as u, OpenApiInfo as v, RenderedOpenApi as x, OpenApiSecurityRequirement as y };