better-supabase 0.14.0 → 0.15.0

package/dist/types-Dp3UCr1e.d.ts

@@ -0,0 +1,194 @@
+/// <reference lib="esnext.temporal" />
+import { o as Message } from "./messaging-C_Pr9tGx.js";
+//#region src/blocks/inbox/types.d.ts
+/** The channels an inbox can sit on. */
+type InboxChannel = "in_app" | "email" | "slack" | "teams" | "discord" | "telegram" | "whatsapp" | "messenger" | "instagram" | "sms" | "github" | "linear" | "other";
+/** `bot`: the bot answers; `human`: staff answer; `paused`: nobody answers. */
+type BotMode = "bot" | "human" | "paused";
+type ConversationStatus = "open" | "pending" | "snoozed" | "resolved";
+type ConversationPriority = "low" | "normal" | "high" | "urgent";
+type MessageDirection = "inbound" | "outbound";
+type AuthorType = "contact" | "agent" | "bot" | "system";
+type DeliveryStatus = "queued" | "sent" | "delivered" | "read" | "failed";
+interface InboxRow {
+  readonly id: string;
+  readonly tenant: string;
+  readonly name: string;
+  readonly channel: InboxChannel;
+  readonly address: string | null;
+  readonly installationId: string | null;
+  readonly botMode: BotMode;
+  readonly settings: Readonly<Record<string, unknown>>;
+  readonly createdAt: Temporal.Instant;
+  readonly archivedAt: Temporal.Instant | null;
+}
+interface Contact {
+  readonly id: string;
+  readonly tenant?: string;
+  readonly userId: string | null;
+  readonly name: string | null;
+  readonly email: string | null;
+  readonly phone: string | null;
+  readonly avatarUrl: string | null;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface Conversation {
+  readonly id: string;
+  readonly tenant: string;
+  readonly inboxId: string;
+  readonly contactId: string;
+  readonly subject: string | null;
+  readonly status: ConversationStatus;
+  readonly priority: ConversationPriority;
+  readonly assigneeId: string | null;
+  readonly teamId: string | null;
+  readonly botMode: BotMode;
+  /** The Chat SDK thread id, or `inbox:<id>` for the in-app widget. */
+  readonly threadId: string;
+  readonly snoozedUntil: Temporal.Instant | null;
+  readonly lastMessageAt: Temporal.Instant | null;
+  readonly preview: string | null;
+  readonly firstResponseAt: Temporal.Instant | null;
+  readonly resolvedAt: Temporal.Instant | null;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly createdAt: Temporal.Instant;
+  readonly contact: Contact | null;
+  readonly inbox: {
+    readonly id: string;
+    readonly name: string;
+    readonly channel: InboxChannel;
+  } | null;
+  /** When the caller last read it. */
+  readonly lastReadAt: Temporal.Instant | null;
+  /** When the contact last read it; `null` for contacts and before they read. */
+  readonly contactReadAt: Temporal.Instant | null;
+  /** In lists: whether a message arrived after `lastReadAt`. */
+  readonly unread?: boolean;
+}
+/**
+ * A file that arrived on a channel. The inbox stores it as a pending
+ * attachment; the service fetches it with `files.pending()` and uploads it.
+ */
+interface InboxFileSource {
+  /** Where the channel serves it. */
+  readonly url?: string;
+  /** Or a Storage object the caller already wrote. */
+  readonly path?: string;
+  /** The bucket of `path`; files migrated from the inbox are in `inbox-files`. */
+  readonly bucket?: string;
+  readonly name?: string;
+  readonly contentType?: string;
+  readonly size?: number;
+}
+/** A channel file waiting to be fetched, from `files.pending()`. */
+interface PendingInboxFile {
+  /** The attachment id: confirm it after the upload. */
+  readonly id: string;
+  readonly conversationId: string;
+  readonly messageId: string;
+  readonly tenant: string;
+  readonly bucket: string;
+  /** Where to upload it. */
+  readonly path: string;
+  readonly name: string;
+  readonly mimeType: string | undefined;
+  readonly source: InboxFileSource;
+}
+/** A Storage upload slot from `messages.createUpload`. */
+interface InboxUpload {
+  readonly id: string;
+  readonly bucket: string;
+  readonly path: string;
+}
+interface MessageDelivery {
+  readonly channel: string;
+  readonly status: DeliveryStatus;
+  readonly error: string | null;
+}
+/**
+ * A core message with the inbox's details. `kind: "note"` is an internal note
+ * only staff read.
+ */
+interface InboxMessage extends Message {
+  readonly direction: MessageDirection;
+  readonly authorType: AuthorType;
+  readonly format: "text" | "markdown";
+  readonly externalId: string | null;
+  readonly replyTo: string | null;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  /** For staff: the first delivery on the channel. */
+  readonly delivery?: MessageDelivery | null;
+}
+interface ConversationEvent {
+  readonly id: string;
+  readonly type: string;
+  readonly actorId: string | null;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly createdAt: Temporal.Instant;
+}
+interface InboxCounts {
+  readonly open: number;
+  readonly mine: number;
+  readonly unassigned: number;
+  readonly unread: number;
+}
+/** What `purgeContact` erased. */
+interface PurgedContact {
+  readonly conversations: number;
+  readonly messages: number;
+  /** The erased attachments' Storage objects, for the caller to remove. */
+  readonly attachments: readonly {
+    readonly bucket: string;
+    readonly path: string;
+  }[];
+}
+interface InboundResult {
+  readonly conversationId: string;
+  readonly messageId: string;
+  readonly contactId: string;
+  readonly tenant: string;
+  /** A new conversation was opened for the thread. */
+  readonly created: boolean;
+  /** The message's `externalId` was already stored. */
+  readonly duplicate: boolean;
+}
+interface MessageTemplate {
+  readonly id: string;
+  readonly tenant: string;
+  readonly inboxId: string | null;
+  readonly name: string;
+  readonly channel: string;
+  readonly language: string;
+  readonly body: string;
+  readonly variables: readonly string[];
+  /** The provider's approved template name (WhatsApp). */
+  readonly externalId: string | null;
+}
+/** A staff reply waiting for `scheduledFor`; only its author sees it. */
+interface ScheduledInboxMessage {
+  readonly id: string;
+  readonly tenant: string;
+  readonly conversationId: string;
+  readonly authorId: string;
+  readonly body: string;
+  readonly format: "text" | "markdown" | null;
+  readonly attachments: readonly string[];
+  readonly mentions: readonly string[];
+  readonly replyTo: string | null;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly scheduledFor: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+}
+interface StoredInboundEvent {
+  readonly id: string;
+  readonly adapter: string;
+  readonly externalId: string | null;
+  readonly inboxId: string | null;
+  readonly tenant: string | null;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly body: string;
+  readonly attempts: number;
+  readonly receivedAt: Temporal.Instant;
+}
+//#endregion
+export { StoredInboundEvent as S, MessageDirection as _, ConversationEvent as a, PurgedContact as b, DeliveryStatus as c, InboxCounts as d, InboxFileSource as f, MessageDelivery as g, InboxUpload as h, Conversation as i, InboundResult as l, InboxRow as m, BotMode as n, ConversationPriority as o, InboxMessage as p, Contact as r, ConversationStatus as s, AuthorType as t, InboxChannel as u, MessageTemplate as v, ScheduledInboxMessage as x, PendingInboxFile as y };

package/dist/types-Dr9wZgNy.d.ts

@@ -0,0 +1,251 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "./standard-DBV730sF.js";
+import { r as FieldsOf } from "./block-fields-BE7pInWZ.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { 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 { i as AiMessage } from "./message-Bg4TKA12.js";
+//#region src/blocks/upload-claim.d.ts
+/** The claim step of a Storage API, such as the one `supportStorage` returns. */
+interface UploadClaimStorage {
+  claimSignedUpload?(bucket: string, path: string): PromiseLike<{
+    readonly data: unknown;
+    readonly error: unknown;
+  }>;
+}
+//#endregion
+//#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 extends UploadClaimStorage {
+  from(bucket: string): AiFileBucket;
+}
+interface AiFilesOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  /**
+   * A Standard Schema for the file columns the app adds
+   * (`blocks.ai-files.options.extraColumns`), keyed by column name. It types
+   * and parses them on the file reads, and validates them on `files.upload` and
+   * `files.store`, which return a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<AiFiles<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  /** 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 (`blocks["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<F extends object = Record<never, never>> {
+  readonly file: AiFile & F;
+  /**
+   * 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;
+}
+/** `F` is the extra file fields `options.fields` describes. */
+interface AiFiles<F extends object = Record<never, never>> {
+  readonly files: {
+    /**
+     * Reserves the file and returns a signed upload URL for its path. Keys
+     * besides the input's own are the file's extra columns.
+     */
+    upload(organizationId: string, file: NewAiFile & Partial<F>): AsyncResult<AiFileUpload<F>>;
+    /** Marks the upload done once the object exists. */
+    confirm(fileId: string, sha256?: string): AsyncResult<AiFile & F>;
+    get(fileId: string): AsyncResult<AiFile & F>;
+    /** The file a `supabase-storage://` URL names, when the caller may read it. */
+    resolve(url: string | URL): AsyncResult<AiFile & F>;
+    list(chatId: string): AsyncResult<readonly (AiFile & F)[]>;
+    /** 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 & F;
+      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 & Partial<F>): AsyncResult<AiFile & F>;
+    /**
+     * 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>;
+    upsert(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, UploadClaimStorage as y };

package/dist/types-EO2crSX_.d.ts

@@ -0,0 +1,177 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { i as CredentialRef, r as CredentialProvider } from "./provider-CqwEOLCA.js";
+import { i as CursorPageOptions, 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";
+//#region src/blocks/ai-keys/types.d.ts
+/**
+ * A tenant's own key for a provider. The key itself stays in the credential
+ * provider.
+ */
+interface AiProviderKey {
+  readonly id: string;
+  readonly organizationId: string;
+  /** The AI Gateway's provider slug, such as `anthropic` or `openai`. */
+  readonly provider: string;
+  /** Tells several keys of one provider apart; `default` unless named. */
+  readonly name: string;
+  readonly credentialRef: CredentialRef;
+  /** The provider's other options, such as a region; never a secret. */
+  readonly settings: Readonly<Record<string, unknown>>;
+  readonly enabled: boolean;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface AiProviderKeyInput {
+  readonly provider: string;
+  /**
+   * Store the key first, for example with `vaultCredentials().set(ref,
+   * apiKey)`.
+   */
+  readonly credentialRef: CredentialRef;
+  readonly name?: string;
+  readonly settings?: Readonly<Record<string, unknown>>;
+  readonly enabled?: boolean;
+}
+/** A key resolved for one request. */
+interface ResolvedProviderKey {
+  readonly provider: string;
+  readonly name: string;
+  readonly token: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly settings: Readonly<Record<string, unknown>>;
+}
+type AiBatchStatus = "pending" | "completed" | "failed" | "cancelled";
+interface AiBatchCounts {
+  readonly total?: number;
+  readonly pending?: number;
+  readonly completed?: number;
+  readonly failed?: number;
+}
+interface AiBatch {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly userId: string | undefined;
+  readonly provider: string;
+  /** The SDK's batch reference, such as `{ version, id, provider }`. */
+  readonly reference: Readonly<Record<string, unknown>>;
+  readonly status: AiBatchStatus;
+  /** The provider's own status word. */
+  readonly rawStatus: string | undefined;
+  readonly itemCount: number;
+  readonly counts: AiBatchCounts;
+  readonly error: string | undefined;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  /** The results are in `items`. */
+  readonly resultsSaved: boolean;
+  readonly polls: number;
+  readonly nextPollAt: Temporal.Instant | undefined;
+  readonly expiresAt: Temporal.Instant | undefined;
+  readonly completedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface NewAiBatch {
+  readonly provider: string;
+  readonly reference: Readonly<Record<string, unknown>>;
+  readonly itemCount?: number;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  /** Service role only: the user the batch is for. */
+  readonly userId?: string;
+  readonly status?: AiBatchStatus;
+  readonly rawStatus?: string;
+  readonly counts?: AiBatchCounts;
+  readonly expiresAt?: Temporal.Instant;
+}
+interface AiBatchPatch {
+  readonly status?: AiBatchStatus;
+  readonly rawStatus?: string;
+  readonly counts?: AiBatchCounts;
+  readonly error?: string | null;
+  readonly expiresAt?: Temporal.Instant;
+  readonly resultsSaved?: boolean;
+  /** `null` stops polling. */
+  readonly nextPollAt?: Temporal.Instant | null;
+}
+type AiBatchItemStatus = "succeeded" | "failed" | "cancelled" | "expired";
+interface AiBatchItem {
+  readonly batchId: string;
+  readonly requestId: string;
+  readonly organizationId: string;
+  readonly status: AiBatchItemStatus;
+  readonly output: unknown;
+  readonly usage: unknown;
+  readonly error: string | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+interface AiBatchItemInput {
+  readonly requestId: string;
+  readonly status: AiBatchItemStatus;
+  readonly output?: unknown;
+  readonly usage?: unknown;
+  readonly error?: string;
+}
+interface AiKeysOptions extends BlockTemporalOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<AiKeys>>;
+  /** 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 resolving keys, polling and the idle stop. */
+  readonly service?: BlockTransport;
+  /** Resolves and revokes the keys' credential refs. */
+  readonly credentials?: CredentialProvider;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`. Default `better_supabase`.
+   */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface AiKeys {
+  readonly keys: {
+    list(organizationId: string): AsyncResult<readonly AiProviderKey[]>;
+    /**
+     * Adds or replaces a key (`ai.admin`), and revokes the credential it
+     * replaced.
+     */
+    upsert(organizationId: string, key: AiProviderKeyInput): AsyncResult<AiProviderKey>;
+    /** Deletes a key and revokes its credential. `false` when there was none. */
+    remove(keyId: string): AsyncResult<boolean>;
+    /**
+     * Deletes every key of a tenant and revokes each credential (service role):
+     * the step to run when a tenant is deleted. Returns how many.
+     */
+    removeAll(organizationId: string): AsyncResult<number>;
+    /**
+     * The tenant's enabled keys with their tokens, for one request (service
+     * role).
+     */
+    resolve(organizationId: string, options?: {
+      readonly providers?: readonly string[];
+      readonly signal?: AbortSignal;
+    }): AsyncResult<readonly ResolvedProviderKey[]>;
+  };
+  readonly batches: {
+    record(organizationId: string, batch: NewAiBatch): AsyncResult<AiBatch>;
+    get(batchId: string): AsyncResult<AiBatch | undefined>;
+    list(organizationId: string, options?: {
+      readonly status?: AiBatchStatus;
+      readonly limit?: number;
+    }): AsyncResult<readonly AiBatch[]>;
+    items(batchId: string, options?: CursorPageOptions<string>): AsyncResult<readonly AiBatchItem[]>;
+    /** Claims batches to poll for `leaseSeconds` (service role). */
+    due(options?: {
+      readonly batch?: number;
+      readonly leaseSeconds?: number;
+    }): AsyncResult<readonly AiBatch[]>;
+    update(batchId: string, patch: AiBatchPatch): AsyncResult<AiBatch>;
+    saveItems(batchId: string, items: readonly AiBatchItemInput[]): AsyncResult<number>;
+  };
+}
+//#endregion
+export { AiBatchItemStatus as a, AiKeys as c, AiProviderKeyInput as d, NewAiBatch as f, AiBatchItemInput as i, AiKeysOptions as l, AiBatchCounts as n, AiBatchPatch as o, ResolvedProviderKey as p, AiBatchItem as r, AiBatchStatus as s, AiBatch as t, AiProviderKey as u };