better-supabase 0.13.0 → 0.14.0

package/dist/inbox-BPBb6etH.d.ts

@@ -0,0 +1,321 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { i as CursorPageOptions, 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 { p as MessageReaction } from "./messaging-CZ6aWb10.js";
+import { S as StoredInboundEvent, a as ConversationEvent, b as PurgedContact, c as DeliveryStatus, d as InboxCounts, f as InboxFileSource, h as InboxUpload, i as Conversation, l as InboundResult, m as InboxRow, n as BotMode, o as ConversationPriority, p as InboxMessage, r as Contact, s as ConversationStatus, u as InboxChannel, v as MessageTemplate, x as ScheduledInboxMessage, y as PendingInboxFile } from "./types-DkPE7yd2.js";
+//#region src/blocks/inbox/inbox.d.ts
+interface InboxOptions extends BlockTemporalOptions {
+  /**
+   * `sqlTransport(postgres.asUser(claims))` or `rpcTransport(supabase)` for a
+   * member or a contact; over the service role for webhooks and workers.
+   */
+  readonly transport: 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[];
+  /** `withBlockHooks` hooks around the methods (ADR 0015). */
+  readonly hooks?: InboxHooks;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
+}
+interface CreateInboxInput {
+  readonly tenant: string;
+  readonly name: string;
+  readonly channel?: InboxChannel;
+  /** The channel's address: a phone number, a Slack team id, an email. */
+  readonly address?: string;
+  readonly botMode?: BotMode;
+  /**
+   * `widget: true` lets signed-in visitors open conversations in an in-app
+   * inbox.
+   */
+  readonly settings?: Readonly<Record<string, unknown>>;
+}
+interface InboxPatch {
+  readonly name?: string;
+  readonly botMode?: BotMode;
+  readonly settings?: Readonly<Record<string, unknown>>;
+  readonly address?: string | null;
+  readonly installationId?: string | null;
+  readonly archived?: boolean;
+}
+interface ContactInput {
+  readonly id?: string;
+  readonly userId?: string;
+  readonly name?: string;
+  readonly email?: string;
+  readonly phone?: string;
+  readonly avatarUrl?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  /** The contact's id on a channel, such as a WhatsApp number. */
+  readonly identity?: {
+    readonly channel: string;
+    readonly externalId: string;
+  };
+}
+interface MessageInput {
+  readonly body: string;
+  /** `note` is an internal note only staff see. */
+  readonly kind?: "message" | "note";
+  readonly format?: "text" | "markdown";
+  /** Ids from `messages.createUpload`, uploaded by the caller. */
+  readonly attachments?: readonly string[];
+  /**
+   * For the service: files that arrived on a channel. Each becomes a pending
+   * attachment for `files.pending()`.
+   */
+  readonly files?: readonly InboxFileSource[];
+  /** User ids; those who cannot read the inbox are dropped. */
+  readonly mentions?: readonly string[];
+  readonly replyTo?: string;
+  readonly externalId?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  /** For the service: who writes. Defaults to `bot`. */
+  readonly authorType?: "contact" | "bot" | "system";
+  /**
+   * For the service: the caller posts to the channel itself, so no outbound job
+   * is queued.
+   */
+  readonly deliveredByCaller?: boolean;
+}
+/** What a scheduled reply carries: a message without the service's fields. */
+type ScheduledMessageInput = Pick<MessageInput, "body" | "format" | "attachments" | "mentions" | "replyTo" | "metadata">;
+interface StartConversationInput {
+  /**
+   * A contact id or the fields to find or create one. Leave it out on a widget
+   * inbox to open the conversation as the signed-in visitor, staff included.
+   */
+  readonly contact?: string | ContactInput;
+  readonly subject?: string;
+  readonly priority?: ConversationPriority;
+  readonly botMode?: BotMode;
+  /** The Chat SDK thread id. Defaults to `inbox:<conversation id>`. */
+  readonly threadId?: string;
+  readonly assigneeId?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  readonly message?: string | MessageInput;
+}
+interface InboundInput {
+  readonly inboxId: string;
+  readonly threadId: string;
+  readonly contact: ContactInput & {
+    /** Shorthand for `identity` on the inbox's channel. */
+    readonly externalId?: string;
+  };
+  readonly message: Omit<MessageInput, "kind" | "authorType" | "attachments">;
+  readonly subject?: string;
+  /** `outbound` records a message sent from the platform by someone else. */
+  readonly direction?: "inbound" | "outbound";
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface ConversationFilter extends CursorPageOptions<Pick<Conversation, "id" | "lastMessageAt">> {
+  readonly inboxId?: string;
+  /** Defaults to `open`. */
+  readonly status?: ConversationStatus | "all";
+  readonly assignee?: "me" | "unassigned" | (string & {});
+  readonly teamId?: string;
+  readonly contactId?: string;
+  readonly search?: string;
+  /** The last item of the previous page. */
+  readonly cursor?: Pick<Conversation, "id" | "lastMessageAt">;
+  /** Up to 200. Defaults to 50. */
+  readonly limit?: number;
+}
+interface TemplateInput {
+  readonly name: string;
+  readonly channel: string;
+  readonly body: string;
+  readonly language?: string;
+  readonly inboxId?: string;
+  readonly variables?: readonly string[];
+  readonly externalId?: string;
+}
+/** The `inbox` SQL module as typed calls. */
+/** Hooks for `Inbox`: the top-level methods, and each group's under its name. */
+type InboxHooks = BlockHooks<Inbox> & {
+  readonly inboxes?: BlockHooks<Inbox["inboxes"]>;
+  readonly contacts?: BlockHooks<Inbox["contacts"]>;
+  readonly conversations?: BlockHooks<Inbox["conversations"]>;
+  readonly messages?: BlockHooks<Inbox["messages"]>;
+  readonly files?: BlockHooks<Inbox["files"]>;
+  readonly deliveries?: BlockHooks<Inbox["deliveries"]>;
+  readonly templates?: BlockHooks<Inbox["templates"]>;
+  readonly inbound?: BlockHooks<Inbox["inbound"]>;
+};
+interface Inbox {
+  readonly inboxes: {
+    create(input: CreateInboxInput): AsyncResult<InboxRow>;
+    update(id: string, patch: InboxPatch): AsyncResult<InboxRow>;
+    /** `null` removes the member. */
+    setMember(inboxId: string, userId: string, role: "agent" | "lead" | null): AsyncResult<boolean>;
+    createTeam(tenant: string, name: string): AsyncResult<{
+      readonly id: string;
+      readonly name: string;
+    }>;
+    setTeamMember(teamId: string, userId: string, present?: boolean): AsyncResult<boolean>;
+  };
+  readonly contacts: {
+    /**
+     * Finds the contact by id, identity, user or email, filling in what is
+     * missing.
+     */
+    upsert(tenant: string, input: ContactInput): AsyncResult<Contact>;
+  };
+  readonly conversations: {
+    open(inboxId: string, input?: StartConversationInput): AsyncResult<Conversation>;
+    list(tenant: string | null, filter?: ConversationFilter): AsyncResult<readonly Conversation[]>;
+    get(conversationId: string): AsyncResult<Conversation | null>;
+    assign(conversationId: string, to: {
+      readonly assigneeId: string | null;
+      readonly teamId?: string | null;
+    }): AsyncResult<Conversation>;
+    setStatus(conversationId: string, status: ConversationStatus, options?: {
+      readonly snoozedUntil?: Temporal.Instant;
+    }): AsyncResult<Conversation>;
+    snooze(conversationId: string, until: Temporal.Instant): AsyncResult<Conversation>;
+    resolve(conversationId: string): AsyncResult<Conversation>;
+    reopen(conversationId: string): AsyncResult<Conversation>;
+    /** Hands a bot conversation to staff (`bot_mode = 'human'`) and tells them. */
+    handoff(conversationId: string, reason?: string): AsyncResult<Conversation>;
+    setBotMode(conversationId: string, mode: BotMode, reason?: string): AsyncResult<Conversation>;
+    markRead(conversationId: string): AsyncResult<Temporal.Instant>;
+    /**
+     * A typing ping on the conversation's messaging topic; the service names
+     * the bot in `actor`.
+     */
+    typing(conversationId: string, typing?: boolean, actor?: string): AsyncResult<boolean>;
+    events(conversationId: string): AsyncResult<readonly ConversationEvent[]>;
+    counts(tenant: string): AsyncResult<InboxCounts>;
+  };
+  readonly messages: {
+    send(conversationId: string, input: MessageInput): AsyncResult<InboxMessage>;
+    /** An internal note only staff see. */
+    note(conversationId: string, body: string, input?: Pick<MessageInput, "mentions" | "attachments" | "format">): AsyncResult<InboxMessage>;
+    list(conversationId: string, options?: CursorPageOptions<Temporal.Instant>): AsyncResult<readonly InboxMessage[]>;
+    get(messageId: string): AsyncResult<InboxMessage | null>;
+    edit(messageId: string, body: string): AsyncResult<InboxMessage>;
+    /** Leaves a tombstone with an empty body and deletes its attachments. */
+    remove(messageId: string): AsyncResult<InboxMessage>;
+    /** Needs the `reactions` module; returns the message's reactions. */
+    react(messageId: string, emoji: string, options?: {
+      readonly present?: boolean;
+      readonly actor?: string;
+    }): AsyncResult<readonly MessageReaction[]>;
+    /**
+     * A pending attachment on the conversation to upload a file to. Upload it
+     * to `bucket` at `path`, call `confirmUpload`, then pass its id in
+     * `attachments`.
+     */
+    createUpload(conversationId: string, file: {
+      readonly name: string;
+      readonly mimeType?: string;
+      readonly size?: number;
+    }): AsyncResult<InboxUpload>;
+    /** Marks the uploaded file as stored (the `attachments` module). */
+    confirmUpload(attachmentId: string): AsyncResult<void>;
+    /**
+     * Schedules a staff reply for `at` (in the future). It is sent as the
+     * caller when `publishDue` runs after that time; until then only the caller
+     * sees it.
+     */
+    schedule(conversationId: string, input: ScheduledMessageInput, at: Temporal.Instant): AsyncResult<ScheduledInboxMessage>;
+    /**
+     * The caller's scheduled replies, soonest first, on one conversation or
+     * all.
+     */
+    scheduled(conversationId?: string): AsyncResult<readonly ScheduledInboxMessage[]>;
+    /** Moves the caller's scheduled reply to another future time. */
+    reschedule(scheduledId: string, at: Temporal.Instant): AsyncResult<ScheduledInboxMessage>;
+    /** Deletes the caller's scheduled reply before it is sent. */
+    cancelScheduled(scheduledId: string): AsyncResult<void>;
+  };
+  /** Service only: the files that arrived on channels. */
+  readonly files: {
+    /** The channel files to fetch and upload, oldest first. */
+    pending(limit?: number): AsyncResult<readonly PendingInboxFile[]>;
+    /** Confirms a fetched and uploaded file. */
+    stored(attachmentId: string): AsyncResult<void>;
+    /** Gives up on a file the channel no longer serves. */
+    failed(attachmentId: string, detail?: string): AsyncResult<boolean>;
+  };
+  readonly deliveries: {
+    /** Service only: after posting a message on its channel. */
+    record(input: {
+      readonly messageId: string;
+      readonly channel: string;
+      readonly externalId?: string;
+      readonly status?: DeliveryStatus;
+      readonly error?: string;
+    }): AsyncResult<void>;
+    /** Service only: a status callback; returns how many deliveries moved. */
+    setStatus(input: {
+      readonly channel: string;
+      readonly externalId: string;
+      readonly status: DeliveryStatus;
+      readonly error?: string;
+    }): AsyncResult<number>;
+  };
+  readonly templates: {
+    upsert(tenant: string, input: TemplateInput): AsyncResult<MessageTemplate>;
+    delete(id: string): AsyncResult<boolean>;
+  };
+  /** Service only: channel messages, the webhook store and its sweeps. */
+  readonly inbound: {
+    /**
+     * A message that arrived on a channel: finds or opens the thread's
+     * conversation.
+     */
+    record(input: InboundInput): AsyncResult<InboundResult>;
+    store(input: {
+      readonly adapter: string;
+      readonly body: string;
+      readonly externalId?: string;
+      readonly headers?: Readonly<Record<string, string>>;
+      readonly inboxId?: string;
+      readonly tenant?: string;
+    }): AsyncResult<{
+      readonly id: string;
+      readonly duplicate: boolean;
+    }>;
+    setStatus(id: string, status: "processing" | "processed" | "ignored" | "failed", error?: string): AsyncResult<boolean>;
+    pending(options?: {
+      readonly limit?: number;
+      readonly maxAttempts?: number;
+    }): AsyncResult<readonly StoredInboundEvent[]>;
+    purge(options?: {
+      readonly olderThan?: number | string;
+      readonly batch?: number;
+    }): AsyncResult<number>;
+  };
+  /**
+   * Service only: reopens snoozed conversations whose time came, with the
+   * `inbox_conversation.unsnoozed` event and a notification. Returns the
+   * count.
+   */
+  wakeSnoozed(): AsyncResult<number>;
+  /**
+   * Service only: sends the scheduled replies whose time came, as their
+   * authors. Returns the number sent.
+   */
+  publishDue(maxRows?: number): AsyncResult<number>;
+  /**
+   * Erases a contact and its conversations for a data subject request
+   * (`inbox.manage` or the service). Remove the returned Storage objects
+   * afterwards.
+   */
+  purgeContact(contactId: string): AsyncResult<PurgedContact>;
+}
+/**
+ * The `inbox` SQL module as typed calls: inboxes, contacts, conversations,
+ * messages and notes, assignment, bot hand-off, read state, deliveries and the
+ * stored webhook events. The database checks every permission.
+ */
+declare function createInbox(options: InboxOptions): Inbox;
+//#endregion
+export { Inbox as a, InboxPatch as c, StartConversationInput as d, TemplateInput as f, InboundInput as i, MessageInput as l, ConversationFilter as n, InboxHooks as o, createInbox as p, CreateInboxInput as r, InboxOptions as s, ContactInput as t, ScheduledMessageInput as u };

package/dist/index-BSUX4dlB.d.ts

@@ -0,0 +1,305 @@
+import { Et as AppTableConfig, _t as AppColumnConfig, an as PresetFieldKey, en as Preset, h as PresetCatalog, jt as AppTablesConfig, nn as PresetCodeField, o as presetConfig, u as ResolvedPreset, v as PresetGlueItem, yt as AppColumnType } from "./config-BuOz_O-y.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/preset/blocks.d.ts
+/**
+ * Every block a preset code can select, by bit position. Append-only: a new
+ * block goes at the end, and a removed block becomes `null` (a tombstone) so
+ * the blocks after it keep their bits. A test checks that it lists every SQL
+ * module.
+ */
+declare const PRESET_BLOCKS: readonly (string | null)[];
+//#endregion
+//#region src/preset/catalog.generated.d.ts
+declare const PRESET_CATALOG: PresetCatalog;
+//#endregion
+//#region src/preset/code.d.ts
+/** What `decodePreset` returns. */
+interface DecodedPreset {
+  readonly preset: Preset;
+  /** The code version the code was written with. */
+  readonly version: number;
+  /** Fields the code's version predates, set to their defaults. */
+  readonly derived: readonly PresetFieldKey[];
+}
+/** The fields and blocks a code is read against; tests pass their own. */
+interface PresetLayout {
+  readonly fields: readonly PresetCodeField[];
+  readonly blocks: readonly (string | null)[];
+  readonly version: number;
+}
+/**
+ * The preset as a code: a version character, then base62 of one BigInt that
+ * holds each field's value index and a bit per selected block.
+ */
+declare function encodePreset(preset: Partial<Preset>, layout?: PresetLayout): string;
+/**
+ * The preset with one convention set to `value`, checked against the field: a
+ * value the field doesn't list throws. For a field that takes several values
+ * (`integrations`), `value` switches that one on or off.
+ */
+declare function withPresetField(preset: Preset, key: PresetFieldKey, value: string): Preset;
+/**
+ * Reads a code from `encodePreset`. A code from an older version decodes with
+ * the fields it predates at their defaults, listed in `derived`. A code from a
+ * newer release throws, naming the upgrade.
+ */
+declare function decodePreset(code: string, layout?: PresetLayout): DecodedPreset;
+/**
+ * Whether `value` reads as a preset code rather than a preset name: a version
+ * character (`1` to `9`, then `A` to `Z`) and base62 digits.
+ */
+declare function isPresetCode(value: string): boolean;
+//#endregion
+//#region src/config/app-defaults.d.ts
+/**
+ * Why `value` can't be the default of `column`, or `undefined` when it can: it
+ * must be on the `isAppDefault` allowlist, one of the column's `options`, and
+ * inside its bounds (`min`, `max`, or those of its format).
+ */
+declare function appDefaultError(column: Pick<AppColumnConfig, "type" | "options" | "min" | "max" | "format">, value: string): string | undefined;
+/** Whether `value` is a default `type` accepts; see `AppColumnConfig.default`. */
+declare function isAppDefault(type: AppColumnType, value: string): boolean;
+//#endregion
+//#region src/preset/design.d.ts
+/**
+ * What the `/create` canvas adds to a preset (ADR 0040): tables the app owns,
+ * extra columns on block tables, and where each table sits on the canvas. It
+ * travels in the `&design=` parameter of a `/create` URL.
+ */
+interface CreateDesign {
+  /** `config.appTables`. */
+  readonly appTables?: Readonly<Record<string, AppTableConfig>>;
+  /**
+   * `blocks.<module>.options.extraColumns`: column name to SQL type, per
+   * module.
+   */
+  readonly extraColumns?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  /** Canvas positions by `schema.table`, as `[x, y]`; the config ignores them. */
+  readonly positions?: Readonly<Record<string, readonly [number, number]>>;
+}
+/**
+ * The newest format of the design JSON, in its `version` key (ADR 0042). A code
+ * carries the lowest format that reads it, and none for format 0, so a design
+ * without format 1 keys still opens in an older release. Format 1 adds column
+ * `format`, `options`, `min`, `max`, `comment` and `identity`, and table `id`,
+ * `unique`, `indexes` and `comment`. Format 2 adds table `subject` (ADR 0043).
+ * Format 3 adds table `rollups` and `lookups` (ADR 0044). Format 4 adds table
+ * `events` (ADR 0048) and subject `versions`. Format 5 adds column `access`
+ * (ADR 0051). Format 6 adds column `encrypted` and table `auditReads` (ADR
+ * 0087).
+ */
+declare const DESIGN_FORMAT = 6;
+/** The lowest design format that reads `design`. */
+declare function designFormat(design: CreateDesign): number;
+/** The longest design code, so a `/create` URL stays under common limits. */
+declare const MAX_DESIGN_CODE_LENGTH = 6e3;
+/** The name Create gives the design file it downloads. */
+declare const DESIGN_FILE = "better-supabase.design.json";
+/**
+ * Why a design, a design code or a design file was rejected. The codes are
+ * stable; the messages may change.
+ */
+type DesignErrorCode = "invalid_design" | "unknown_key" | "unsupported_format" | "too_large" | "unknown_block" | "no_extra_columns" | "block_not_installed" | "invalid_name" | "invalid_type" | "invalid_position" | "invalid_app_table" | "invalid_code" | "too_long" | "invalid_file" | "invalid_preset";
+/** One problem with a design, as `safeParseDesign` reports it. */
+interface DesignParseIssue {
+  readonly code: DesignErrorCode;
+  /**
+   * A JSON Pointer (RFC 6901) to the key at fault in the value that was read,
+   * such as `/appTables/tasks/columns/title`. `""` is the value itself. When
+   * the key is missing, it points to the nearest parent.
+   */
+  readonly path: string;
+  readonly message: string;
+}
+/**
+ * What `parseDesign`, `decodeDesign`, `designFileSource` and `readDesignFile`
+ * throw.
+ */
+declare class DesignParseError extends TypeError implements DesignParseIssue {
+  readonly code: DesignErrorCode;
+  readonly path: string;
+  constructor(code: DesignErrorCode, path: string, message: string, options?: ErrorOptions);
+  /** The issue as a plain, serializable object. */
+  toJSON(): DesignParseIssue;
+}
+/**
+ * What `encodeDesign` throws when a valid design is too long for a URL, so a
+ * caller can offer the config download instead of a fix.
+ */
+declare class DesignTooLongError extends DesignParseError {
+  /** The length the code would have. */
+  readonly length: number;
+  constructor(length: number);
+}
+/** Whether `value` has the shape of a design code. It may still fail to decode. */
+declare function isDesignCode(value: string): boolean;
+/**
+ * Checks a design object, such as one from storage or a request body, and drops
+ * its empty parts. It runs the same checks as `decodeDesign`, without the code.
+ * Throws a `DesignParseError` naming the first problem; `safeParseDesign`
+ * returns it instead.
+ */
+declare function parseDesign(value: unknown): CreateDesign;
+/** What `safeParseDesign` and `safeDesignFileSource` return. */
+type DesignParseResult<T> = ({
+  readonly ok: true;
+} & T) | {
+  readonly ok: false;
+  readonly issues: readonly DesignParseIssue[];
+};
+/**
+ * `parseDesign` without the throw: the design, or the issue that stopped it,
+ * with a stable `code` and a JSON Pointer `path`.
+ */
+declare function safeParseDesign(value: unknown): DesignParseResult<{
+  readonly design: CreateDesign;
+}>;
+/**
+ * A Standard Schema (v1) for a design, so a form library, a router or an AI SDK
+ * tool can validate one with the same rules as `parseDesign`. The output drops
+ * the empty parts; each issue's `path` lists the keys of its JSON Pointer.
+ * `schemas/design-v1.json` is the JSON Schema of its shape.
+ */
+declare const designSchema: StandardSchemaV1<unknown, CreateDesign>;
+/**
+ * The design as a code for the `&design=` parameter: `0`, then its JSON (with
+ * `version` set to `designFormat` when it is above 0) compressed with
+ * deflate-raw, in base64url. An empty design is `""`. Throws a
+ * `DesignParseError` when the design is invalid, and a `DesignTooLongError`
+ * when the code would be longer than `MAX_DESIGN_CODE_LENGTH`.
+ */
+declare function encodeDesign(design: CreateDesign): Promise<string>;
+/** Reads a design code. Throws a `DesignParseError` when it isn't a valid one. */
+declare function decodeDesign(code: string): Promise<CreateDesign>;
+/**
+ * The design in a `/create` URL's `&design=` parameter, or in a bare design
+ * code; `undefined` when `input` has neither.
+ */
+declare function designOf(input: string): Promise<CreateDesign | undefined>;
+/**
+ * The config keys a preset with a design sets: `presetConfig`, with each
+ * block's `options.extraColumns` and `appTables`. Throws a `DesignParseError`
+ * when the design adds columns to a block the preset doesn't install.
+ */
+declare function designConfig(resolved: ResolvedPreset, design: CreateDesign): ReturnType<typeof presetConfig> & {
+  readonly appTables?: AppTablesConfig;
+};
+/**
+ * `better-supabase.config.ts` for a preset with a design. `designCode`, the
+ * design's `encodeDesign`, goes into the `/create` URL in the comment, so the
+ * canvas reopens with its positions.
+ */
+declare function designConfigSource(resolved: ResolvedPreset, design: CreateDesign, designCode?: string): string;
+/**
+ * The command that starts a project from the preset and design: `init` with the
+ * quoted `/create` URL, or `presetInstallCommand` when `designCode` is empty.
+ */
+declare function designInstallCommand(resolved: ResolvedPreset, designCode: string): string;
+/**
+ * A preset and its design as one JSON file, for a design too long for a URL
+ * (ADR 0058). `init --preset` and `apply --preset` read it from a path.
+ */
+interface DesignFile {
+  /** The preset code. */
+  readonly preset: string;
+  /** The design, with `version` set to `designFormat` when it is above 0. */
+  readonly design: CreateDesign & {
+    readonly version?: number;
+  };
+}
+/**
+ * The design file for a preset and design, as JSON text. Throws a
+ * `DesignParseError` when the design is invalid; `safeDesignFileSource` returns
+ * it instead. It has no length limit.
+ */
+declare function designFileSource(resolved: ResolvedPreset, design: CreateDesign): string;
+/**
+ * `designFileSource` without the throw: the file text, or the issue that
+ * stopped it. Each `path` points into the design.
+ */
+declare function safeDesignFileSource(resolved: ResolvedPreset, design: CreateDesign): DesignParseResult<{
+  readonly source: string;
+}>;
+/**
+ * Reads a design file's text. Each `DesignParseError` path points into the
+ * file, so a design problem starts with `/design`. Throws one naming the first
+ * problem: text that isn't JSON, a missing or invalid preset, or an invalid
+ * design.
+ */
+declare function readDesignFile(text: string): {
+  readonly preset: Preset;
+  readonly design: CreateDesign;
+};
+/** The command that applies the preset and design to an existing project. */
+declare function designApplyCommand(resolved: ResolvedPreset, designCode: string): string;
+//#endregion
+//#region src/preset/design-diff.d.ts
+/** What changed between two sets of app tables. */
+type DesignChangeKind = "table.added" | "table.dropped" | "table.renamed" | "table.id" | "table.scope" | "table.unique" | "table.columns" | "table.changed" | "table.computed" | "table.events" | "table.versions" | "column.added" | "column.dropped" | "column.renamed" | "column.type" | "column.required" | "column.unique" | "column.options" | "column.bounds" | "column.format" | "column.reference" | "column.access" | "column.encrypted" | "column.changed";
+interface DesignChange {
+  readonly kind: DesignChangeKind;
+  readonly table: string;
+  readonly column?: string;
+  /** The old name of a renamed table or column, or the old type. */
+  readonly from?: string;
+  /** The new type of a type change. */
+  readonly to?: string;
+  /**
+   * True when existing rows or app code can break: a dropped or renamed table
+   * or column, a type change, a column made required without a default, a new
+   * or tighter constraint (unique, options, bounds, format, a reference
+   * target), tighter column access, encryption turned on or off, a new scope,
+   * or removed generated columns.
+   */
+  readonly breaking: boolean;
+  readonly summary: string;
+  /** The expand-and-contract steps that make a breaking change safe. */
+  readonly steps: readonly string[];
+}
+interface DiffOptions {
+  /**
+   * Leave out tables that `after` doesn't have, as `apply` does: it writes the
+   * tables of a design and keeps the others.
+   */
+  readonly keepMissing?: boolean;
+}
+/**
+ * What changes from `before` to `after`: each added, dropped, renamed or
+ * changed table and column, with the breaking ones marked and their
+ * expand-and-contract steps. A rename is a dropped name and an added one with
+ * the same definition.
+ */
+declare function diffAppTables(before: AppTablesConfig, after: AppTablesConfig, options?: DiffOptions): readonly DesignChange[];
+/** `diffAppTables` over the app tables of two `/create` designs. */
+declare function diffDesigns(before: CreateDesign, after: CreateDesign): readonly DesignChange[];
+//#endregion
+//#region src/preset/render.d.ts
+/** The comment a config with the provider access model gets above `blocks`. */
+declare const PROVIDER_COMMENT: readonly string[];
+/**
+ * `better-supabase.config.ts` for a resolved preset: every block with its
+ * reason, and the conventions that differ from the defaults.
+ */
+declare function presetConfigSource(resolved: ResolvedPreset): string;
+/**
+ * `lib/blocks.ts`: the blocks with a TypeScript client, wired with
+ * `defineBlocks` over the Data API as the caller. Each block's schema (the API
+ * schema when `sql.api` is set) and shared options come from `blockConfig`,
+ * which `better-supabase gen` writes to `blocks.generated.ts`;
+ * `blockConfigImport` is its import path.
+ */
+declare function presetBlocksSource(resolved: ResolvedPreset, blockConfigImport?: string): string;
+/**
+ * The registry glue for the preset's framework and platforms: each item whose
+ * blocks are all installed, except bundles and items that write
+ * `lib/blocks.ts`, which the preset writes itself.
+ */
+declare function presetGlue(resolved: ResolvedPreset, catalog?: PresetCatalog): readonly PresetGlueItem[];
+/** The shadcn command that copies glue items into the app. */
+declare function glueCommand(items: readonly PresetGlueItem[]): string;
+/** The command that starts a project from the preset. */
+declare function presetInstallCommand(resolved: ResolvedPreset): string;
+/** The command that applies the preset to an existing project. */
+declare function presetApplyCommand(resolved: ResolvedPreset): string;
+//#endregion
+export { designOf as A, DecodedPreset as B, decodeDesign as C, designFileSource as D, designConfigSource as E, readDesignFile as F, PRESET_CATALOG as G, encodePreset as H, safeDesignFileSource as I, PRESET_BLOCKS as K, safeParseDesign as L, encodeDesign as M, isDesignCode as N, designFormat as O, parseDesign as P, appDefaultError as R, MAX_DESIGN_CODE_LENGTH as S, designConfig as T, isPresetCode as U, decodePreset as V, withPresetField as W, DesignFile as _, presetConfigSource as a, DesignParseResult as b, DesignChange as c, diffAppTables as d, diffDesigns as f, DesignErrorCode as g, DESIGN_FORMAT as h, presetBlocksSource as i, designSchema as j, designInstallCommand as k, DesignChangeKind as l, DESIGN_FILE as m, glueCommand as n, presetGlue as o, CreateDesign as p, presetApplyCommand as r, presetInstallCommand as s, PROVIDER_COMMENT as t, DiffOptions as u, DesignParseError as v, designApplyCommand as w, DesignTooLongError as x, DesignParseIssue as y, isAppDefault as z };