better-supabase 0.5.0 → 0.6.0

package/dist/types-BI-0Sl2v.d.ts

@@ -0,0 +1,359 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "./result-D7y2fT87.js";
+import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
+import { i as CredentialRef, o as CredentialToken, r as CredentialProvider } from "./provider-BH5UWZJ6.js";
+import { r as BlockTemporalOptions } from "./block-helpers-CKtbFcRv.js";
+import { a as WorkflowSchedule, u as WorkflowStarter } from "./workflows-B0j9WKPu.js";
+//#region src/blocks/workflow-builder/graph.d.ts
+type WorkflowNodeKind = "trigger" | "step" | "sleep" | "approval" | "condition";
+type WorkflowConditionOperator = "equals" | "notEquals" | "exists" | "truthy" | "greaterThan" | "lessThan" | "contains";
+/**
+ * A test on the run's data. `path` starts at `input` (the trigger's input)
+ * or `results` (each node's output by node id), e.g. `results.lookup.plan`.
+ */
+interface WorkflowCondition {
+  readonly path: string;
+  readonly op: WorkflowConditionOperator;
+  readonly value?: unknown;
+}
+/**
+ * One node of a graph. A `step` node calls the library step `step` with its
+ * `config`; a `sleep` node waits `config.duration` (milliseconds, or `30s`,
+ * `5m`, `2h`, `1d`); an `approval` node waits for its hook to be resumed;
+ * a `condition` node tests `config` (a `WorkflowCondition`).
+ */
+interface WorkflowGraphNode {
+  readonly id: string;
+  readonly kind: WorkflowNodeKind;
+  readonly label?: string;
+  readonly step?: string;
+  readonly config?: Readonly<Record<string, unknown>>;
+  /** Where the canvas draws it; the engines ignore it. */
+  readonly position?: {
+    readonly x: number;
+    readonly y: number;
+  };
+}
+/**
+ * An edge runs its target after its source. From a `condition` or an
+ * `approval` node, `branch` picks the outcome it follows (an approval is
+ * `true` unless its payload has `approved: false`).
+ */
+interface WorkflowGraphEdge {
+  readonly id: string;
+  readonly source: string;
+  readonly target: string;
+  readonly branch?: "true" | "false";
+}
+/** The engine-neutral graph a workflow version stores. */
+interface WorkflowGraph {
+  readonly nodes: readonly WorkflowGraphNode[];
+  readonly edges: readonly WorkflowGraphEdge[];
+}
+/** A sleep duration in milliseconds; `undefined` when `value` isn't one. */
+declare function durationMs(value: unknown): number | undefined;
+/** Whether `condition` holds for the run's data. */
+declare function evaluateCondition(condition: WorkflowCondition, scope: {
+  readonly input: unknown;
+  readonly results: unknown;
+}): boolean;
+/** Whether an approval payload approves: anything but `{ approved: false }`. */
+declare const approved: (payload: unknown) => boolean;
+/**
+ * The nodes in an order that runs every source before its targets, keeping
+ * the graph's order among independent nodes; `undefined` when edges form a
+ * cycle.
+ */
+declare function topologicalOrder(graph: WorkflowGraph): readonly WorkflowGraphNode[] | undefined;
+/**
+ * Problems that keep `graph` from running, as messages; empty when it can.
+ * Pass the step library's names to check that every step node uses one
+ * (`publish` checks it again in SQL).
+ */
+declare function validateGraph(graph: unknown, steps?: Iterable<string>): readonly string[];
+interface WorkflowGraphDiff {
+  readonly nodes: {
+    readonly added: readonly string[];
+    readonly removed: readonly string[];
+    /** Nodes whose kind, step, label or config changed; moving one doesn't count. */
+    readonly changed: readonly string[];
+  };
+  readonly edges: {
+    readonly added: readonly string[];
+    readonly removed: readonly string[];
+  };
+}
+/** What changed from `before` to `after`, by node id and by edge ends. */
+declare function diffGraphs(before: WorkflowGraph, after: WorkflowGraph): WorkflowGraphDiff;
+//#endregion
+//#region src/blocks/workflow-builder/types.d.ts
+type WorkflowVersionStatus = "draft" | "published" | "archived";
+type WorkflowTriggerKind = "manual" | "webhook" | "schedule" | "event" | "form" | "chat";
+type WorkflowNodeRunStatus = "running" | "waiting" | "completed" | "failed" | "skipped";
+interface WorkflowDefinition {
+  readonly id: string;
+  readonly tenant: string | undefined;
+  readonly slug: string;
+  readonly name: string;
+  readonly description: string | undefined;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+  /** The published version's number (lists only). */
+  readonly published?: number | undefined;
+  /** Whether a draft is open (lists only). */
+  readonly draft?: boolean;
+}
+interface WorkflowVersion {
+  readonly id: string;
+  readonly definition: string;
+  readonly version: number;
+  readonly status: WorkflowVersionStatus;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly publishedAt: Temporal.Instant | undefined;
+  /** Set by `get`, `save` and `publish`; lists leave it out. */
+  readonly graph?: WorkflowGraph;
+  /** What the engine's `compile` returned on publish. */
+  readonly compiled?: unknown;
+}
+interface WorkflowTrigger {
+  readonly id: string;
+  readonly definition: string;
+  readonly kind: WorkflowTriggerKind;
+  /**
+   * `schedule`: `{ cron, timezone?, input? }`; `event`: `{ type }`; `form`:
+   * `{ schema }`; the others are the app's.
+   */
+  readonly config: Readonly<Record<string, unknown>>;
+  readonly enabled: boolean;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** A credential a tenant's steps use, by reference: the row never holds the secret. */
+interface WorkflowCredential {
+  readonly id: string;
+  readonly tenant: string | undefined;
+  /** What it is for, matched against a step's `credentialKind`. */
+  readonly kind: string;
+  readonly name: string;
+  readonly ref: CredentialRef;
+  readonly scopes: readonly string[];
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+/** A step the deployment provides, as the builder's palette shows it. */
+interface WorkflowStepInfo {
+  readonly name: string;
+  readonly title: string;
+  readonly description?: string | undefined;
+  /** JSON Schema of the node's config. */
+  readonly inputSchema?: Readonly<Record<string, unknown>>;
+  readonly outputSchema?: Readonly<Record<string, unknown>>;
+  /** The credential kind the step resolves, when it needs one. */
+  readonly credentialKind?: string | undefined;
+}
+interface WorkflowNodeRun {
+  readonly run: string;
+  readonly node: string;
+  readonly status: WorkflowNodeRunStatus;
+  readonly attempts: number;
+  readonly output: unknown;
+  readonly error: string | undefined;
+  readonly startedAt: Temporal.Instant | undefined;
+  readonly endedAt: Temporal.Instant | undefined;
+}
+interface WorkflowAlert {
+  readonly id: string;
+  readonly definition: string;
+  readonly onEvent: "failed" | "slow";
+  /** Seconds a run may stay unfinished (slow alerts). */
+  readonly threshold: number | undefined;
+  /** Where the app sends it, e.g. `{ type: "email", to }`; the module only stores it. */
+  readonly channel: Readonly<Record<string, unknown>>;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+/** What `start` gets to start a run of a published version. */
+interface BuilderStartCall {
+  readonly definition: WorkflowDefinition;
+  /** The published version, with its graph and compiled form. */
+  readonly version: WorkflowVersion;
+  readonly input: unknown;
+  readonly tenant: string | undefined;
+  readonly actor: string | undefined;
+  /** Pass to the engine so a repeated start returns the same run. */
+  readonly idempotencyKey: string;
+  /** The trigger that started it, when one did. */
+  readonly trigger?: WorkflowTrigger;
+}
+/** Starts a run with the engine and returns the engine's run id. */
+type BuilderStarter = ((call: BuilderStartCall) => Promise<string>) & {
+  /** The starter contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+};
+/** The engine's compiled form of a graph, stored with the version on publish. */
+type GraphCompiler = ((graph: WorkflowGraph) => unknown) & {
+  /** The compiler contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+};
+interface BuilderOptions extends BlockTemporalOptions {
+  /** The caller's transport: RLS and the module's permissions apply. */
+  readonly transport: BlockTransport;
+  /**
+   * A service-role transport for the calls only the server makes: webhook
+   * and event targets, `credentials.resolve`, `nodeRuns.record`,
+   * `steps.sync` and `alerts.check`. Defaults to `transport`.
+   */
+  readonly service?: BlockTransport;
+  /** The module schema (`sql.modules.workflow-builder.schema`), default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** The steps `steps.sync()` writes to the library. */
+  readonly steps?: readonly WorkflowStepInfo[];
+  /**
+   * Runs on publish and fails it when it throws; the result is stored
+   * through `service`. `better-supabase/workflow-sdk/builder` exports `compileGraph`.
+   */
+  readonly compile?: GraphCompiler;
+  /** Starts runs; `better-supabase/workflow-sdk/builder` exports `graphStarter`. */
+  readonly start?: BuilderStarter;
+  /** The providers credential rows resolve through, picked by `ref.provider`. */
+  readonly credentials?: CredentialProvider | readonly CredentialProvider[];
+}
+interface DefinitionInput {
+  readonly tenant?: string;
+  /** Lowercase letters, digits and dashes; saving the same slug again renames it. */
+  readonly slug: string;
+  readonly name: string;
+  readonly description?: string;
+}
+interface TriggerInput {
+  readonly definition: string;
+  readonly kind: WorkflowTriggerKind;
+  readonly config?: Readonly<Record<string, unknown>>;
+  readonly enabled?: boolean;
+  /** Updates this trigger instead of creating one. */
+  readonly id?: string;
+}
+interface CredentialInput {
+  readonly tenant?: string;
+  readonly kind: string;
+  readonly name: string;
+  readonly ref: CredentialRef;
+  readonly scopes?: readonly string[];
+  /** Stores the secret first, through a provider that can (`vaultCredentials` can). */
+  readonly secret?: string;
+}
+interface AlertInput {
+  readonly definition: string;
+  readonly onEvent: "failed" | "slow";
+  readonly channel?: Readonly<Record<string, unknown>>;
+  /** Seconds a run may stay unfinished (slow alerts). */
+  readonly threshold?: number;
+  readonly id?: string;
+}
+interface NodeRunRecord {
+  /** The run's id or its engine's id. */
+  readonly run: string;
+  readonly node: string;
+  readonly status: WorkflowNodeRunStatus;
+  readonly attempt?: number;
+  readonly output?: unknown;
+  readonly error?: string;
+}
+interface RunInput {
+  readonly definition: string;
+  readonly input?: unknown;
+  /** Defaults to a fresh key, so every call starts a run. */
+  readonly idempotencyKey?: string;
+  readonly actor?: string;
+}
+interface OutboxLikeEvent {
+  readonly id: string;
+  readonly type: string;
+  readonly payload?: unknown;
+  readonly tenant?: string | undefined;
+}
+interface WorkflowBuilder {
+  readonly definitions: {
+    save(input: DefinitionInput): AsyncResult<WorkflowDefinition>;
+    list(tenant?: string): AsyncResult<readonly WorkflowDefinition[]>;
+    get(id: string): AsyncResult<WorkflowDefinition | undefined>;
+    remove(id: string): AsyncResult<boolean>;
+  };
+  readonly versions: {
+    /** Saves the draft: updates the open one, or opens the next version. */
+    save(definition: string, graph: WorkflowGraph): AsyncResult<WorkflowVersion>;
+    /**
+     * Compiles the graph with `compile`, then publishes as the caller; the
+     * previous version is archived. The compiled form is stored through
+     * `service` only, and not at all without it.
+     */
+    publish(version: string): AsyncResult<WorkflowVersion>;
+    list(definition: string): AsyncResult<readonly WorkflowVersion[]>;
+    get(version: string): AsyncResult<WorkflowVersion | undefined>;
+    diff(from: string, to: string): AsyncResult<WorkflowGraphDiff>;
+  };
+  /** Starts a run of the published version: `workflow.run` in its tenant. */
+  run(input: RunInput): AsyncResult<string>;
+  readonly triggers: {
+    save(input: TriggerInput): AsyncResult<WorkflowTrigger>;
+    list(definition: string): AsyncResult<readonly WorkflowTrigger[]>;
+    remove(id: string): AsyncResult<boolean>;
+    /** A new token for a webhook trigger; the old one stops working. Shown once. */
+    rotateToken(id: string): AsyncResult<string>;
+    /**
+     * A route handler for webhook triggers: the token is the last path
+     * segment or a `Bearer` header, the JSON body is the input, and an
+     * `Idempotency-Key` header keys the start. Answers 202 with `{ runId }`.
+     */
+    webhook(request: Request): Promise<Response>;
+    /** Starts the definitions whose event triggers listen for `event.type`. */
+    onEvent(event: OutboxLikeEvent): AsyncResult<readonly string[]>;
+    /**
+     * Creates or updates the `workflows` schedule of a schedule trigger (its
+     * `config.cron`), named `builder-trigger:<id>`. Uses `service`.
+     */
+    syncSchedule(trigger: WorkflowTrigger, tenant?: string): AsyncResult<WorkflowSchedule>;
+    /**
+     * The `start` for `workflows.schedules.tick`: starts `builder:<definition>`
+     * schedules here and passes the others to `fallback`.
+     */
+    starter(fallback?: WorkflowStarter): WorkflowStarter;
+  };
+  readonly credentials: {
+    list(tenant?: string): AsyncResult<readonly WorkflowCredential[]>;
+    create(input: CredentialInput): AsyncResult<WorkflowCredential>;
+    /** The URL that connects the account, for providers that authorize. */
+    authorize(id: string, options: {
+      readonly redirectUri: string;
+      readonly state?: string;
+    }): AsyncResult<string>;
+    /** Deletes the row, then revokes the secret it names. */
+    revoke(id: string): AsyncResult<boolean>;
+    /** The token for a credential, with the app subject and the row's scopes (service role; call it inside a step). */
+    resolve(id: string): AsyncResult<CredentialToken>;
+  };
+  readonly steps: {
+    /** Replaces the library with `steps` (service role). */
+    sync(steps?: readonly WorkflowStepInfo[]): AsyncResult<number>;
+    list(): AsyncResult<readonly WorkflowStepInfo[]>;
+  };
+  readonly nodeRuns: {
+    /** Records a node's status and pings `workflow-run:<id>` (service role). */
+    record(input: NodeRunRecord): AsyncResult<boolean>;
+    list(run: string): AsyncResult<readonly WorkflowNodeRun[]>;
+  };
+  readonly alerts: {
+    save(input: AlertInput): AsyncResult<WorkflowAlert>;
+    list(definition: string): AsyncResult<readonly WorkflowAlert[]>;
+    remove(id: string): AsyncResult<boolean>;
+    /** Fires the slow alerts that are due (service role); returns how many fired. */
+    check(options?: {
+      readonly batch?: number;
+    }): AsyncResult<number>;
+  };
+}
+//#endregion
+export { approved as A, WorkflowCondition as C, WorkflowGraphEdge as D, WorkflowGraphDiff as E, validateGraph as F, durationMs as M, evaluateCondition as N, WorkflowGraphNode as O, topologicalOrder as P, WorkflowVersionStatus as S, WorkflowGraph as T, WorkflowNodeRunStatus as _, CredentialInput as a, WorkflowTriggerKind as b, NodeRunRecord as c, TriggerInput as d, WorkflowAlert as f, WorkflowNodeRun as g, WorkflowDefinition as h, BuilderStarter as i, diffGraphs as j, WorkflowNodeKind as k, OutboxLikeEvent as l, WorkflowCredential as m, BuilderOptions as n, DefinitionInput as o, WorkflowBuilder as p, BuilderStartCall as r, GraphCompiler as s, AlertInput as t, RunInput as u, WorkflowStepInfo as v, WorkflowConditionOperator as w, WorkflowVersion as x, WorkflowTrigger as y };

package/dist/types-C05bxW-W.d.ts

@@ -0,0 +1,220 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "./result-D7y2fT87.js";
+import { t as BlockTransport } from "./block-transport-DvaoPuZ9.js";
+import { a as AiMessage } from "./message-CfDoR0Y6.js";
+import { r as BlockTemporalOptions } from "./block-helpers-CKtbFcRv.js";
+//#region src/blocks/ai-files/types.d.ts
+interface StorageReply<T> {
+  readonly data: T | null;
+  readonly error: unknown;
+}
+/** The `supabase.storage.from(bucket)` methods the block uses. */
+interface AiFileBucket {
+  createSignedUploadUrl(path: string): PromiseLike<StorageReply<{
+    readonly signedUrl: string;
+    readonly token: string;
+  }>>;
+  createSignedUrl(path: string, expiresIn: number): PromiseLike<StorageReply<{
+    readonly signedUrl: string;
+  }>>;
+  download(path: string): PromiseLike<StorageReply<Blob>>;
+  remove(paths: string[]): PromiseLike<StorageReply<unknown>>;
+  upload?(path: string, body: Blob | ArrayBuffer | Uint8Array, options?: {
+    readonly contentType?: string;
+    readonly upsert?: boolean;
+  }): PromiseLike<StorageReply<unknown>>;
+}
+/** `supabase.storage`, typed structurally. */
+interface AiFileStorage {
+  from(bucket: string): AiFileBucket;
+}
+interface AiFilesOptions extends BlockTemporalOptions {
+  /** Calls as the user: `rpcTransport(supabase)`. */
+  readonly transport: BlockTransport;
+  /** The user's `supabase.storage`, so the bucket policies apply. */
+  readonly storage: AiFileStorage;
+  /** Calls as the service role, for `store`, provider files and `purge`. */
+  readonly service?: BlockTransport;
+  /** The service role's `supabase.storage`, for `store` and `purge`. */
+  readonly serviceStorage?: AiFileStorage;
+  /** The module schema (`sql.modules["ai-files"].schema`), default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** Lifetime of a signed download URL in seconds. Default 300. */
+  readonly downloadTtl?: number;
+  /** The most bytes `read` returns before it fails. Default 50 MB. */
+  readonly maxBytes?: number;
+}
+type AiFileStatus = "pending" | "ready" | "failed";
+type AiFileSource = "upload" | "generated" | "provider";
+interface AiFile {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly ownerId: string;
+  readonly chatId: string | undefined;
+  readonly projectId: string | undefined;
+  readonly bucket: string;
+  /** `{organizationId}/{ownerId}/{id}/{filename}` in the bucket. */
+  readonly path: string;
+  readonly mediaType: string;
+  readonly filename: string;
+  readonly size: number;
+  readonly sha256: string | undefined;
+  readonly status: AiFileStatus;
+  readonly source: AiFileSource;
+  readonly createdAt: Temporal.Instant;
+  readonly uploadedAt: Temporal.Instant | undefined;
+  readonly expiresAt: Temporal.Instant | undefined;
+}
+interface NewAiFile {
+  readonly filename: string;
+  readonly mediaType: string;
+  /** Bytes; `confirm()` replaces it with the stored size. */
+  readonly size: number;
+  readonly chatId?: string;
+  readonly projectId?: string;
+}
+interface AiFileUpload {
+  readonly file: AiFile;
+  /** PUT the file here, or pass `token` to `uploadToSignedUrl(path, token, file)`. */
+  readonly signedUrl: string;
+  readonly token: string;
+}
+interface StoredAiFile {
+  /** The user the file belongs to. */
+  readonly ownerId: string;
+  readonly filename: string;
+  readonly mediaType: string;
+  readonly data: Uint8Array | Blob;
+  readonly chatId?: string;
+  readonly source?: AiFileSource;
+}
+interface AiProviderFile {
+  readonly fileId: string;
+  readonly provider: string;
+  /** What the provider's file API returned: a file id or a file URI. */
+  readonly reference: string;
+  readonly expiresAt: Temporal.Instant | undefined;
+}
+type AiDocumentKind = "text" | "code" | "sheet" | "image";
+interface AiDocument {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly ownerId: string;
+  readonly chatId: string | undefined;
+  readonly kind: AiDocumentKind;
+  readonly title: string;
+  readonly version: number;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** A document with the content of its current version. */
+interface AiDocumentWithContent extends AiDocument {
+  readonly content: string | undefined;
+  /** A path in the bucket, for an image or a large document. */
+  readonly storagePath: string | undefined;
+}
+interface AiDocumentVersion {
+  readonly documentId: string;
+  readonly version: number;
+  readonly content: string | undefined;
+  readonly storagePath: string | undefined;
+  /** The assistant message that wrote this version. */
+  readonly messageId: string | undefined;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+interface NewAiDocument {
+  readonly kind: AiDocumentKind;
+  readonly title: string;
+  readonly content?: string;
+  readonly storagePath?: string;
+  readonly chatId?: string;
+  readonly messageId?: string;
+  /** The service role only: the user the document belongs to. */
+  readonly ownerId?: string;
+}
+interface AiDocumentEdit {
+  readonly content?: string;
+  readonly storagePath?: string;
+  readonly title?: string;
+  readonly messageId?: string;
+  /** Fails with `conflict` when the document moved past this version. */
+  readonly expectedVersion?: number;
+}
+interface AiSuggestion {
+  readonly id: string;
+  readonly documentId: string;
+  readonly version: number;
+  readonly originalText: string;
+  readonly suggestedText: string;
+  readonly description: string | undefined;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly resolvedAt: Temporal.Instant | undefined;
+  readonly accepted: boolean | undefined;
+}
+interface AiFiles {
+  readonly files: {
+    /** Reserves the file and returns a signed upload URL for its path. */
+    upload(organizationId: string, file: NewAiFile): AsyncResult<AiFileUpload>;
+    /** Marks the upload done once the object exists. */
+    confirm(fileId: string, sha256?: string): AsyncResult<AiFile>;
+    get(fileId: string): AsyncResult<AiFile>;
+    /** The file a `supabase-storage://` URL names, when the caller may read it. */
+    resolve(url: string | URL): AsyncResult<AiFile>;
+    list(chatId: string): AsyncResult<readonly AiFile[]>;
+    /** A signed download URL that expires after `downloadTtl`. */
+    sign(file: AiFile | string): AsyncResult<string>;
+    /** The bytes of a ready file, refusing more than `maxBytes`. */
+    read(file: AiFile | string): AsyncResult<{
+      readonly file: AiFile;
+      readonly data: Uint8Array;
+    }>;
+    /** Deletes the object and the record. */
+    remove(fileId: string): AsyncResult<boolean>;
+    /** Writes a ready file for `ownerId` from the server (service role). */
+    store(organizationId: string, file: StoredAiFile): AsyncResult<AiFile>;
+    /**
+     * Deletes stale pending uploads, expired files and the files of
+     * deleted chats, then their objects (service role). Returns how many.
+     */
+    purge(options?: {
+      readonly olderThan?: string;
+      readonly batch?: number;
+    }): AsyncResult<number>;
+  };
+  readonly providerFiles: {
+    /** The provider's reference while it is valid (service role). */
+    get(fileId: string, provider: string): AsyncResult<AiProviderFile | undefined>;
+    set(fileId: string, provider: string, reference: string, expiresAt?: Temporal.Instant): AsyncResult<boolean>;
+    /** References that expire within `horizon` (an interval, default `1 day`). */
+    expiring(horizon?: string, batch?: number): AsyncResult<readonly AiProviderFile[]>;
+  };
+  readonly documents: {
+    create(organizationId: string, document: NewAiDocument): AsyncResult<AiDocument>;
+    get(documentId: string): AsyncResult<AiDocumentWithContent>;
+    update(documentId: string, edit: AiDocumentEdit): AsyncResult<AiDocument>;
+    /** Writes `version` as the newest version again. */
+    rollback(documentId: string, version: number): AsyncResult<AiDocument>;
+    versions(documentId: string): AsyncResult<readonly AiDocumentVersion[]>;
+    remove(documentId: string): AsyncResult<boolean>;
+    suggest(documentId: string, suggestion: {
+      readonly originalText: string;
+      readonly suggestedText: string;
+      readonly description?: string;
+    }): AsyncResult<AiSuggestion>;
+    suggestions(documentId: string, options?: {
+      readonly openOnly?: boolean;
+    }): AsyncResult<readonly AiSuggestion[]>;
+    resolve(suggestionId: string, accepted: boolean): AsyncResult<AiSuggestion>;
+  };
+  /**
+   * Replaces the `supabase-storage://` URLs of file parts with signed
+   * download URLs, so a browser or a provider can fetch them. Parts the
+   * caller may not read keep their URL.
+   */
+  sign(messages: readonly AiMessage[]): Promise<readonly AiMessage[]>;
+}
+//#endregion
+export { NewAiFile as _, AiDocumentWithContent as a, AiFileSource as c, AiFileUpload as d, AiFiles as f, NewAiDocument as g, AiSuggestion as h, AiDocumentVersion as i, AiFileStatus as l, AiProviderFile as m, AiDocumentEdit as n, AiFile as o, AiFilesOptions as p, AiDocumentKind as r, AiFileBucket as s, AiDocument as t, AiFileStorage as u, StoredAiFile as v };