better-supabase 0.14.0 → 0.15.0

package/dist/messaging-C_Pr9tGx.d.ts

@@ -0,0 +1,297 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "./standard-DBV730sF.js";
+import { n as ExtraFields, r as FieldsOf } from "./block-fields-BE7pInWZ.js";
+import { $ as RecordRef } from "./types-DFdg_4yN.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, r as BlockTemporalOptions } from "./block-helpers-CRpAHrp_.js";
+import { t as BlockTransport } from "./block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "./block-hooks-DZN2w69m.js";
+import { t as Author } from "./block-authors-DzXLUiIq.js";
+import { a as ThreadSummary, i as ThreadSummarizer, r as SummaryTarget, t as SummarizeOptions } from "./summaries-8jQTELIX.js";
+//#region src/blocks/messaging/messaging.d.ts
+/** What a conversation is for. */
+type ConversationKind = "channel" | "dm" | "group_dm" | "subject" | "inbox";
+/**
+ * Who reads a conversation: its members, everyone in the tenant who holds
+ * `messages.read`, or whoever reads its record.
+ */
+type ConversationAccess = "members" | "tenant" | "subject";
+/** How a member hears of new messages. */
+type NotifyLevel = "all" | "mentions" | "none";
+interface Conversation {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly kind: ConversationKind;
+  readonly access: ConversationAccess;
+  /** The record of a `subject` conversation. */
+  readonly subject: RecordRef | undefined;
+  readonly title: string | undefined;
+  readonly createdBy: string | undefined;
+  readonly lastMessageAt: Temporal.Instant | undefined;
+  readonly archivedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** A conversation from `listConversations`, with the caller's read state. */
+interface ConversationSummary extends Conversation {
+  /** Top-level messages from others since the caller's read marker. */
+  readonly unread: number;
+  /** How many of those mention the caller, `@channel` and `@here` included. */
+  readonly mentions: number;
+  readonly lastReadAt: Temporal.Instant | undefined;
+  readonly notify: NotifyLevel;
+}
+/** A file on a message, from the `attachments` module. */
+interface MessageFile {
+  readonly id: string;
+  readonly name: string;
+  readonly mimeType: string | undefined;
+  readonly size: number | undefined;
+  /** `pending` until scanned when the bucket requires a scan. */
+  readonly status: string;
+}
+/** One emoji on a message, from the `reactions` module. */
+interface MessageReaction {
+  readonly emoji: string;
+  readonly count: number;
+  readonly reacted: boolean;
+  readonly actors: readonly string[];
+}
+type MessageKind = "message" | "note";
+/** A message. `F` types the extra columns the `fields` schema describes. */
+interface Message<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly conversationId: string;
+  /** The message this replies to. */
+  readonly parentId: string | undefined;
+  /** The thread's root message; `undefined` for a top-level message. */
+  readonly threadId: string | undefined;
+  /** `undefined` once the author's account is deleted. */
+  readonly authorId: string | undefined;
+  /** The author's name and avatar, with the `profiles` module. */
+  readonly author: Author | undefined;
+  /** `note` is an inbox's internal note, which only its staff read. */
+  readonly kind: MessageKind;
+  /** Empty for a deleted message. */
+  readonly body: string;
+  /** The rich-text document an editor wrote, next to `body` as plain text. */
+  readonly document: unknown;
+  /**
+   * Where on the record a top-level message points, such as a text range or a
+   * field (any JSON); `undefined` without one.
+   */
+  readonly anchor: unknown;
+  readonly mentionIds: readonly string[];
+  /** `channel` or `here` when the body says `@channel` or `@here`. */
+  readonly mentionScope: "channel" | "here" | undefined;
+  /** A reply also shown in the conversation. */
+  readonly broadcast: boolean;
+  readonly replyCount: number;
+  readonly lastReplyAt: Temporal.Instant | undefined;
+  /** The first three people who replied. */
+  readonly replyUserIds: readonly string[];
+  readonly pinnedAt: Temporal.Instant | undefined;
+  readonly pinnedBy: string | undefined;
+  readonly resolvedAt: Temporal.Instant | undefined;
+  readonly resolvedBy: string | undefined;
+  /** A scheduled message has `scheduledFor` and no `sentAt` yet. */
+  readonly scheduledFor: Temporal.Instant | undefined;
+  readonly sentAt: Temporal.Instant | undefined;
+  readonly editedAt: Temporal.Instant | undefined;
+  readonly deletedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+  /** Empty without the `attachments` module. */
+  readonly attachments: readonly MessageFile[];
+  /** Empty without the `reactions` module. */
+  readonly reactions: readonly MessageReaction[];
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+/** An earlier version of an edited message. */
+interface MessageEdit {
+  readonly id: string;
+  readonly messageId: string;
+  readonly body: string;
+  readonly document: unknown;
+  readonly editedBy: string | undefined;
+  readonly editedAt: Temporal.Instant;
+}
+interface NewMessage<F extends object = Record<never, never>> {
+  /** Plain text; `@[Name](<user id>)` mentions a user. */
+  readonly body: string;
+  /** A rich-text document (any JSON); keep `body` as its plain text. */
+  readonly document?: unknown;
+  /** Where on the record a top-level message points (any JSON). */
+  readonly anchor?: unknown;
+  /** User ids, merged with the ones the body's markup mentions. */
+  readonly mentionIds?: readonly string[];
+  /** A reply: with one level of threads, a reply to a reply joins the root. */
+  readonly parentId?: string;
+  /** A reply also shown in the conversation. */
+  readonly broadcast?: boolean;
+  /** Sends later: with the `jobs` module, or a cron that runs `publishDue`. */
+  readonly scheduledFor?: Temporal.Instant;
+  /** Files the caller uploaded to the conversation (`attachments`). */
+  readonly attachmentIds?: readonly string[];
+  readonly fields?: Partial<F>;
+}
+interface MessageEdition<F extends object = Record<never, never>> {
+  readonly body: string;
+  /** `null` removes the document; leaving it out keeps it. */
+  readonly document?: unknown;
+  readonly mentionIds?: readonly string[];
+  readonly fields?: Partial<F>;
+}
+interface OpenConversation {
+  readonly kind: "channel" | "dm" | "group_dm" | "subject";
+  /** A channel's name. */
+  readonly title?: string;
+  /** A channel's access: `members` (private) or `tenant`. Default `members`. */
+  readonly access?: "members" | "tenant";
+  /** The record of a `subject` conversation. */
+  readonly subject?: RecordRef;
+  /** The members besides the caller. */
+  readonly memberIds?: readonly string[];
+}
+/** Where a page of messages starts: a message's `sentAt` and `id`. */
+interface MessageCursor {
+  readonly sentAt: Temporal.Instant;
+  readonly id: string;
+}
+interface MessageListOptions {
+  /** The newest messages before this one. */
+  readonly before?: MessageCursor;
+  /** The oldest messages after this one, for catching up. */
+  readonly after?: MessageCursor;
+  readonly limit?: number;
+}
+/** A sent message that mentions a record, from `recordMentions`. */
+interface RecordMention<F extends object = Record<never, never>> {
+  readonly message: Message<F>;
+  /** The message's conversation: a channel, a direct message, a record's thread. */
+  readonly conversation: {
+    readonly id: string;
+    readonly kind: ConversationKind;
+    readonly title: string | undefined;
+    /** The record of a `subject` conversation. */
+    readonly subject: RecordRef | undefined;
+  };
+}
+interface UnreadCount {
+  readonly unread: number;
+  readonly mentions: number;
+}
+/** What `follow` follows: a whole conversation or one thread. */
+type FollowTarget = {
+  readonly conversationId: string;
+} | {
+  readonly threadId: string;
+};
+/** Every method that takes no id acts in the block's `tenant`. */
+interface Messaging<F extends object = Record<never, never>> {
+  /**
+   * Opens a conversation. A direct or group message and a record's conversation
+   * are opened once: opening again returns the same one.
+   */
+  open(conversation: OpenConversation): AsyncResult<Conversation>;
+  /** Opens the direct (one other person) or group message with `userIds`. */
+  openDirect(userIds: readonly string[]): AsyncResult<Conversation>;
+  /** The conversation of a record, read by whoever reads the record. */
+  openSubject(subject: RecordRef): AsyncResult<Conversation>;
+  /** Returns how many joined. Members add members; anyone joins a tenant one. */
+  addMembers(conversationId: string, userIds: readonly string[]): AsyncResult<number>;
+  /** A member leaves, or the owner or a moderator removes them. */
+  removeMember(conversationId: string, userId: string): AsyncResult<boolean>;
+  archive(conversationId: string, archived?: boolean): AsyncResult<boolean>;
+  /** The caller's conversations, latest message first. */
+  conversations(options?: {
+    readonly kinds?: readonly ConversationKind[];
+    readonly limit?: number;
+  }): AsyncResult<ConversationSummary[]>;
+  /** Unread counts by conversation id, for the conversations with any. */
+  unreadCounts(): AsyncResult<Readonly<Record<string, UnreadCount>>>;
+  /** Moves the caller's read marker forward; returns where it is. */
+  markRead(conversationId: string, options?: {
+    readonly threadId?: string;
+    readonly readAt?: Temporal.Instant;
+  }): AsyncResult<Temporal.Instant>;
+  setNotify(conversationId: string, level: NotifyLevel): AsyncResult<boolean>;
+  /** Broadcasts typing on the conversation's topic. */
+  typing(conversationId: string, typing?: boolean): AsyncResult<boolean>;
+  /** With the `notifications` module: hear of every message, or none. */
+  follow(target: FollowTarget, following?: boolean): AsyncResult<boolean>;
+  can(conversationId: string, action: "read" | "send" | "moderate"): AsyncResult<boolean>;
+  send(conversationId: string, message: NewMessage<F>): AsyncResult<Message<F>>;
+  /** The author edits within `editWindow`; the old version is kept. */
+  edit(messageId: string, edition: MessageEdition<F>): AsyncResult<Message<F>>;
+  /** The author or a moderator; the message stays as a placeholder. */
+  remove(messageId: string): AsyncResult<boolean>;
+  pin(messageId: string, pinned?: boolean): AsyncResult<Message<F>>;
+  /** Resolves a thread by its root message, or opens it again. */
+  resolve(messageId: string, resolved?: boolean): AsyncResult<Message<F>>;
+  /** A page of top-level messages (and broadcast replies), oldest first. */
+  list(conversationId: string, options?: MessageListOptions): AsyncResult<Message<F>[]>;
+  /** A thread's replies, oldest first. */
+  replies(messageId: string, options?: {
+    readonly after?: MessageCursor;
+    readonly limit?: number;
+  }): AsyncResult<Message<F>[]>;
+  /** The top-level messages anchored to a file (`fileAnchor`), oldest first. */
+  anchoredTo(attachmentId: string, options?: {
+    readonly limit?: number;
+  }): AsyncResult<Message<F>[]>;
+  /** One message, or `undefined`: for a Realtime ping's id. */
+  get(messageId: string): AsyncResult<Message<F> | undefined>;
+  edits(messageId: string): AsyncResult<MessageEdit[]>;
+  pinned(conversationId: string): AsyncResult<Message<F>[]>;
+  /**
+   * The sent messages that mention a record (`@[Name](subject:<type>/<id>)`),
+   * newest first: its backlinks. Only the messages the caller reads, and none
+   * when they can't read the record.
+   */
+  recordMentions(subject: RecordRef, options?: {
+    readonly before?: MessageCursor;
+    readonly limit?: number;
+  }): AsyncResult<RecordMention<F>[]>;
+  /** The service role sends the scheduled messages that are due. */
+  publishDue(limit?: number): AsyncResult<number>;
+  /**
+   * The summary of a thread or of a conversation's top-level messages, with
+   * whether it is stale; `undefined` before the first one.
+   */
+  summary(target: SummaryTarget): AsyncResult<ThreadSummary | undefined>;
+  /**
+   * Returns the summary while it is current. Otherwise reads the newest
+   * messages as the caller (internal notes left out), asks `summarizer` and
+   * saves what it wrote through the `service` transport.
+   */
+  summarize(target: SummaryTarget, summarizer: ThreadSummarizer, options?: SummarizeOptions): AsyncResult<ThreadSummary>;
+}
+interface MessagingOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions, BlockTenantOptions {
+  readonly transport: BlockTransport;
+  /**
+   * Calls as the service role, to save thread summaries: `rpcTransport(admin)`.
+   * Default `transport`.
+   */
+  readonly service?: BlockTransport;
+  /** The module schema, or its API schema. Default `better_supabase`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the message's extra columns
+   * (`blocks.messaging.options.extraColumns`), keyed by database name.
+   */
+  readonly fields?: S;
+  readonly hooks?: NoInfer<BlockHooks<Messaging<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The messaging block: channels, direct and group messages and record
+ * conversations, with threads, mentions, edits, pins, resolved threads,
+ * scheduled sends, read markers, files and reactions.
+ */
+declare function createMessaging<S extends StandardSchemaV1 | undefined = undefined>(options: MessagingOptions<S>): Messaging<FieldsOf<S>>;
+//#endregion
+export { NotifyLevel as _, FollowTarget as a, UnreadCount as b, MessageEdit as c, MessageKind as d, MessageListOptions as f, NewMessage as g, MessagingOptions as h, ConversationSummary as i, MessageEdition as l, Messaging as m, ConversationAccess as n, Message as o, MessageReaction as p, ConversationKind as r, MessageCursor as s, Conversation as t, MessageFile as u, OpenConversation as v, createMessaging as x, RecordMention as y };

package/dist/methods-B3o7BFOW.js

@@ -0,0 +1,11 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/security-events/options.ts
+const securityEventsSqlOptions = blockOptions({ retention: option.string({ default: "7 days" }) });
+//#endregion
+//#region src/blocks/security-events/methods.ts
+/** RFC 8935 push delivery, as SSF names it in `delivery.method`. */
+const SSF_PUSH = "urn:ietf:rfc:8935";
+/** RFC 8936 poll delivery. */
+const SSF_POLL = "urn:ietf:rfc:8936";
+//#endregion
+export { SSF_PUSH as n, securityEventsSqlOptions as r, SSF_POLL as t };

package/dist/mfa-oIOYTpvc.d.ts

@@ -0,0 +1,36 @@
+import { b as DbError } from "./result-DZeA5KS6.js";
+//#region src/auth/mfa.d.ts
+/**
+ * Authenticator assurance level: `aal2` once a second factor is verified in
+ * this session.
+ */
+type Aal = "aal1" | "aal2";
+/** One way the user proved who they are in this session (the JWT `amr` claim). */
+interface AmrEntry {
+  /** `password`, `otp`, `oauth`, `totp`, `sso/saml`, `anonymous`, ... */
+  readonly method: string;
+  /** Seconds since epoch. */
+  readonly timestamp: number;
+  /** SSO provider id, for `sso/saml`. */
+  readonly provider?: string;
+}
+/**
+ * The session's assurance level from its claims; anything but `aal2` reads as
+ * `aal1`.
+ */
+declare function aalOf(claims: Readonly<Record<string, unknown>>): Aal;
+/** The `amr` claim as typed entries, skipping malformed ones. */
+declare function amrOf(claims: Readonly<Record<string, unknown>>): readonly AmrEntry[];
+/**
+ * `undefined` when a user session meets `required`; otherwise a `forbidden`
+ * error with `required` and code `INSUFFICIENT_AAL`, for the client to start an
+ * MFA challenge. Non-user sessions pass: `allow` decides about them.
+ */
+declare function checkAal(auth: {
+  readonly kind: "user";
+  readonly claims: object;
+} | {
+  readonly kind: string;
+}, required: Aal): DbError | undefined;
+//#endregion
+export { checkAal as a, amrOf as i, AmrEntry as n, aalOf as r, Aal as t };

package/dist/model-hwpvole9.d.ts

@@ -0,0 +1,340 @@
+//#region src/spec/model.d.ts
+/**
+ * A JSON Schema (2020-12) object. Model schemas reference components as
+ * `#/components/schemas/<Name>`.
+ */
+type JsonSchema = Readonly<Record<string, unknown>>;
+/** A JSON object, for extensions and free-form fields. */
+type JsonObject = Readonly<Record<string, unknown>>;
+type ResourceOperation = "list" | "get" | "create" | "update" | "delete";
+/**
+ * A contract verb a table serves as `POST /<table>/<verb>`, next to its REST
+ * operations.
+ */
+type TableVerb = "page" | "count" | "aggregate" | "upsert";
+/** HTTP methods an operation can use; `query` is an OpenAPI 3.2 method. */
+type HttpMethod = "get" | "put" | "post" | "patch" | "delete" | "head" | "options" | "trace" | "query";
+interface ModelParameter {
+  readonly name: string;
+  readonly in: "path" | "query" | "header" | "cookie";
+  readonly required?: boolean;
+  readonly description?: string;
+  readonly deprecated?: boolean;
+  readonly schema: JsonSchema;
+  /** How an array or object query value is written (`form` for `a,b`). */
+  readonly style?: string;
+  readonly explode?: boolean;
+}
+/** A named example of a media type. */
+interface ModelExample {
+  readonly summary?: string;
+  readonly description?: string;
+  readonly value: unknown;
+}
+/**
+ * Media type to its schema. `itemSchema` describes each item of a stream (SSE,
+ * JSON Lines).
+ */
+interface ModelContent {
+  readonly schema?: JsonSchema;
+  readonly itemSchema?: JsonSchema;
+  readonly examples?: Readonly<Record<string, ModelExample>>;
+}
+interface ModelBody {
+  readonly required: boolean;
+  readonly description?: string;
+  readonly content: Readonly<Record<string, ModelContent>>;
+}
+interface ModelResponse {
+  readonly description: string;
+  /** Short summary; native in OpenAPI 3.2. */
+  readonly summary?: string;
+  readonly content?: Readonly<Record<string, ModelContent>>;
+  readonly headers?: Readonly<Record<string, {
+    readonly description?: string;
+    readonly schema: JsonSchema;
+  }>>;
+}
+/** A response, or the name of a shared one in `ApiModel.responses`. */
+type ModelResponseOrRef = ModelResponse | {
+  readonly ref: string;
+};
+/** Scheme name to its required scopes. `[]` means no scopes. */
+type SecurityRequirement = Readonly<Record<string, readonly string[]>>;
+/** Where an operation comes from, so tools and adapters can find their own. */
+type OperationSource = {
+  readonly kind: "resource";
+  readonly table: string;
+  readonly operation: ResourceOperation;
+} | {
+  readonly kind: "action";
+  readonly table: string;
+  readonly action: string;
+} | {
+  readonly kind: "data-api";
+  /** The table's app key, for `select`, `insert`, `update` and `delete`. */
+  readonly table?: string;
+  /** The function's key, for `rpc`. */
+  readonly function?: string;
+  readonly operation: DataApiOperation | "rpc";
+} | {
+  readonly kind: "verb";
+  /** `table` for an app table, `block` for a block instance. */
+  readonly owner: "table" | "block";
+  /** The table's app key or the block instance's key. */
+  readonly name: string;
+  /** The instance's sub-client the verb lives on, such as `chats`. */
+  readonly member?: string;
+  readonly verb: string;
+} | {
+  readonly kind: "route";
+} | {
+  readonly kind: "fragment";
+};
+/** A table operation of the Data API (PostgREST). */
+type DataApiOperation = "select" | "insert" | "update" | "delete";
+interface ModelOperation {
+  /** The operationId: unique across the model. */
+  readonly id: string;
+  readonly method: HttpMethod;
+  /** The OpenAPI path template, e.g. `/api/customers/{id}`. */
+  readonly path: string;
+  readonly summary?: string;
+  readonly description?: string;
+  readonly tags: readonly string[];
+  readonly deprecated?: boolean;
+  readonly parameters: readonly ModelParameter[];
+  readonly requestBody?: ModelBody;
+  readonly responses: Readonly<Record<string, ModelResponseOrRef>>;
+  /**
+   * Overrides the model's `servers`, e.g. the Supabase project for the Data
+   * API.
+   */
+  readonly servers?: readonly ModelServer[];
+  /** Overrides the model's `security`; `[]` makes the operation public. */
+  readonly security?: readonly SecurityRequirement[];
+  /** The permission key the authorizer checks, from `Authorizer.key()`. */
+  readonly permission?: string;
+  readonly source: OperationSource;
+  /** `x-` fields, with their prefix. */
+  readonly extensions: JsonObject;
+  /**
+   * Deep-merged into the operation object a format renders (OpenAPI), after the
+   * fragments, so it wins over both the generated fields and fragments.
+   */
+  readonly extend?: JsonObject;
+}
+interface ModelTag {
+  readonly name: string;
+  readonly summary?: string;
+  readonly description?: string;
+  /** The parent tag's name (OpenAPI 3.2 nested tags). */
+  readonly parent?: string;
+  /** `nav`, `badge` or another value from the OAI Tag Kind registry. */
+  readonly kind?: string;
+}
+interface ModelServer {
+  readonly url: string;
+  /** Native in OpenAPI 3.2. */
+  readonly name?: string;
+  readonly description?: string;
+}
+interface OAuthFlow {
+  readonly authorizationUrl?: string;
+  readonly tokenUrl?: string;
+  readonly refreshUrl?: string;
+  readonly scopes: Readonly<Record<string, string>>;
+}
+type ModelSecurityScheme = {
+  readonly type: "http";
+  readonly scheme: string;
+  readonly bearerFormat?: string;
+  readonly description?: string;
+} | {
+  readonly type: "apiKey";
+  readonly name: string;
+  readonly in: "header" | "query" | "cookie";
+  readonly description?: string;
+} | {
+  readonly type: "oauth2";
+  readonly description?: string;
+  readonly flows: {
+    readonly authorizationCode?: OAuthFlow;
+    readonly clientCredentials?: OAuthFlow;
+    readonly implicit?: OAuthFlow;
+    readonly password?: OAuthFlow;
+  };
+  /** RFC 8414 metadata URL; native in OpenAPI 3.2. */
+  readonly metadataUrl?: string;
+} | {
+  readonly type: "openIdConnect";
+  readonly openIdConnectUrl: string;
+  readonly description?: string;
+} | {
+  /** The Security Profiles proposal; only `3.3-preview` emits it. */
+  readonly type: "profile";
+  readonly description?: string;
+  readonly profileMetadata: {
+    readonly profile: string;
+    readonly parametersSchema?: string;
+    readonly authorizationServer?: string;
+    readonly servers?: readonly string[];
+  };
+};
+/** A Security Profile Requirement (Security Profiles proposal, preview only). */
+interface ModelSecurityProfileRequirement {
+  readonly scheme: string;
+  readonly operation?: string;
+  readonly tokenEndpointAuthMethods?: readonly string[];
+  readonly grantTypes?: readonly string[];
+  readonly scopes?: readonly string[];
+}
+interface ModelMessage {
+  readonly id: string;
+  readonly name?: string;
+  readonly title?: string;
+  readonly summary?: string;
+  readonly description?: string;
+  readonly contentType?: string;
+  readonly payload: JsonSchema;
+  readonly headers?: JsonSchema;
+  /** A runtime expression such as `$message.payload#/id`. */
+  readonly correlationId?: string;
+  /** Names of shared traits in `ApiModel.messageTraits`, applied in order. */
+  readonly traits?: readonly string[];
+  readonly extensions?: JsonObject;
+}
+/** Fields several messages share, such as the CloudEvents headers. */
+interface ModelMessageTrait {
+  readonly summary?: string;
+  readonly description?: string;
+  readonly contentType?: string;
+  readonly headers?: JsonSchema;
+}
+interface ModelChannelOperation {
+  readonly id: string;
+  readonly action: "send" | "receive";
+  readonly summary?: string;
+  readonly description?: string;
+  /** Message ids, a subset of the channel's. */
+  readonly messages?: readonly string[];
+  readonly permission?: string;
+  readonly extensions?: JsonObject;
+}
+interface ModelChannel {
+  readonly id: string;
+  /** The address with `{param}` placeholders, e.g. `bsb:t:{schema}.{table}`. */
+  readonly address: string;
+  readonly title?: string;
+  readonly summary?: string;
+  readonly description?: string;
+  readonly parameters?: Readonly<Record<string, {
+    readonly description?: string;
+  }>>;
+  /** The protocol the channel runs on: `ws` (Realtime) or `http` (webhooks). */
+  readonly protocol: "ws" | "http";
+  readonly messages: readonly string[];
+  readonly operations: readonly ModelChannelOperation[];
+  readonly extensions?: JsonObject;
+}
+interface ModelWebhook {
+  /** The event name, e.g. `invoice.paid`. */
+  readonly id: string;
+  readonly summary?: string;
+  readonly description?: string;
+  readonly payload: JsonSchema;
+  /**
+   * Standard Webhooks headers (`webhook-id`, `webhook-timestamp`,
+   * `webhook-signature`).
+   */
+  readonly standardWebhooks: boolean;
+}
+/**
+ * A step calls an operation by id or sends or receives on a channel (Arazzo
+ * 1.1).
+ */
+interface ModelStep {
+  readonly id: string;
+  readonly description?: string;
+  readonly operationId?: string;
+  readonly channel?: {
+    readonly id: string;
+    readonly action: "send" | "receive";
+    readonly correlationId?: string;
+  };
+  readonly workflowId?: string;
+  readonly parameters?: readonly {
+    readonly name: string;
+    readonly in?: "path" | "query" | "header" | "cookie";
+    readonly value: unknown;
+  }[];
+  readonly requestBody?: {
+    readonly payload: unknown;
+  };
+  readonly successCriteria?: readonly {
+    readonly condition: string;
+  }[];
+  readonly outputs?: Readonly<Record<string, string>>;
+  readonly onSuccess?: readonly JsonObject[];
+  readonly onFailure?: readonly JsonObject[];
+}
+interface ModelWorkflow {
+  readonly id: string;
+  readonly summary?: string;
+  readonly description?: string;
+  readonly inputs?: JsonSchema;
+  readonly steps: readonly ModelStep[];
+  readonly outputs?: Readonly<Record<string, string>>;
+}
+interface ModelInfo {
+  readonly title: string;
+  readonly version: string;
+  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;
+    readonly identifier?: string;
+    readonly url?: string;
+  };
+}
+/**
+ * A version-neutral description of the API. `defineApi` builds it once; each
+ * `DocumentFormat` lowers it to one version of its format. Formats never mutate
+ * it.
+ */
+interface ApiModel {
+  readonly info: ModelInfo;
+  /** The document's own URL (`$self` in OpenAPI 3.2). */
+  readonly self?: string;
+  readonly servers: readonly ModelServer[];
+  readonly tags: readonly ModelTag[];
+  readonly operations: readonly ModelOperation[];
+  readonly schemas: Readonly<Record<string, JsonSchema>>;
+  /** Shared responses, referenced by name from operations. */
+  readonly responses: Readonly<Record<string, ModelResponse>>;
+  readonly securitySchemes: Readonly<Record<string, ModelSecurityScheme>>;
+  readonly security: readonly SecurityRequirement[];
+  readonly securityProfileRequirements?: Readonly<Record<string, ModelSecurityProfileRequirement>>;
+  readonly channels: readonly ModelChannel[];
+  readonly messages: Readonly<Record<string, ModelMessage>>;
+  readonly messageTraits?: Readonly<Record<string, ModelMessageTrait>>;
+  readonly webhooks: readonly ModelWebhook[];
+  readonly workflows: readonly ModelWorkflow[];
+  /**
+   * OpenAPI fragments (parsed YAML or JSON), deep-merged over the generated
+   * document in order. A field they change is reported as `fragment-conflict`.
+   */
+  readonly fragments: readonly JsonObject[];
+  /** The Realtime websocket URL, the AsyncAPI server. */
+  readonly realtimeUrl?: string;
+  /** Prefix of the generated `x-` fields. Defaults to `x-better-supabase-`. */
+  readonly extensionPrefix: string;
+}
+//#endregion
+export { ModelWebhook as C, ResourceOperation as D, OperationSource as E, SecurityRequirement as O, ModelTag as S, OAuthFlow as T, ModelResponseOrRef as _, JsonSchema as a, ModelServer as b, ModelChannelOperation as c, ModelInfo as d, ModelMessage as f, ModelResponse as g, ModelParameter as h, JsonObject as i, TableVerb as k, ModelContent as l, ModelOperation as m, DataApiOperation as n, ModelBody as o, ModelMessageTrait as p, HttpMethod as r, ModelChannel as s, ApiModel as t, ModelExample as u, ModelSecurityProfileRequirement as v, ModelWorkflow as w, ModelStep as x, ModelSecurityScheme as y };