better-supabase 0.12.0 → 0.14.0

package/dist/approvals-bMb7dsBY.d.ts

@@ -0,0 +1,129 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
+import { r as FieldsOf } from "./block-fields-3w4MZr8U.js";
+import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, 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 { i as AuthorizationHooks, n as Approver } from "./authorization-hooks-dLmUO_PZ.js";
+//#region src/blocks/approvals/approvals.d.ts
+interface ApprovalsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions, BlockTenantOptions {
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`.
+   */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the request columns the app adds
+   * (`blocks.approvals.options.extraColumns`), keyed by column name. It types
+   * and parses them on every read, and validates them on `request`, which
+   * returns a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Approvals<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+  /**
+   * The authorization hooks. `approverOf` sees every approve, reject and
+   * delegate with kind `<subject type>.<action>` and the subject id, after the
+   * SQL eligibility check, and can only refuse. Needs `approver`.
+   */
+  readonly authorization?: Pick<AuthorizationHooks, "approverOf">;
+  /** The signed-in user the transport runs as, for `approverOf`. */
+  readonly approver?: Approver;
+}
+type ApprovalStatus = "pending" | "approved" | "rejected" | "cancelled" | "expired";
+/** Who may decide a step. Any match is enough. */
+interface ApprovalApprovers {
+  readonly permission?: string;
+  readonly role?: string;
+  readonly team?: string;
+  readonly users?: readonly string[];
+}
+interface ApprovalStep {
+  readonly approvers: ApprovalApprovers;
+  readonly required: number;
+}
+interface ApprovalRequest {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subject: SubjectRef;
+  readonly action: string;
+  readonly status: ApprovalStatus;
+  /** The current step, from 0. */
+  readonly step: number;
+  /** The policy's steps when the request was made. */
+  readonly steps: readonly ApprovalStep[];
+  readonly requestedBy?: string;
+  readonly reason?: string;
+  readonly payload: Readonly<Record<string, unknown>>;
+  readonly expiresAt?: Temporal.Instant;
+  readonly decidedAt?: Temporal.Instant;
+  readonly createdAt: Temporal.Instant;
+}
+interface ApprovalDecision {
+  readonly id: string;
+  readonly step: number;
+  readonly approver?: string;
+  readonly decision: "approved" | "rejected" | "delegated";
+  readonly delegateTo?: string;
+  readonly comment?: string;
+  readonly createdAt: Temporal.Instant;
+}
+/** A request with its decisions, from `get`. */
+interface ApprovalRequestDetail extends ApprovalRequest {
+  /** Whether the caller can decide the current step. */
+  readonly canDecide: boolean;
+  readonly decisions: readonly ApprovalDecision[];
+}
+interface ApprovalRequestInput {
+  /** An action `options.policies` names for the subject type. */
+  readonly action: string;
+  readonly reason?: string;
+  /** Passed to the job the final approval enqueues. */
+  readonly payload?: Readonly<Record<string, unknown>>;
+}
+interface ApprovalListOptions {
+  /** `null` lists every status. Default: `pending`. */
+  readonly status?: ApprovalStatus | null;
+  /** Only requests whose current step the caller can decide. */
+  readonly assigned?: boolean;
+  /** Only requests on this subject. */
+  readonly subject?: SubjectRef;
+  readonly pageSize?: number;
+  /** Requests made before this time, for the next page. */
+  readonly before?: Temporal.Instant;
+}
+/**
+ * `F` is the extra request fields `options.fields` describes. `request` and
+ * `list` act in the block's `tenant`.
+ */
+interface Approvals<F extends object = Record<never, never>> {
+  /**
+   * Files a request on `subject` under its type's policy for the action. Keys
+   * besides the input's own are the request's extra columns.
+   */
+  request(subject: SubjectRef, input: ApprovalRequestInput & Partial<F>): AsyncResult<ApprovalRequest & F>;
+  /** Approves the current step; the last step runs the policy's action. */
+  approve(id: string, comment?: string): AsyncResult<ApprovalRequest & F>;
+  /** Rejects the request. */
+  reject(id: string, comment?: string): AsyncResult<ApprovalRequest & F>;
+  /** Hands the caller's place on the current step to another member. */
+  delegate(id: string, userId: string, comment?: string): AsyncResult<ApprovalRequest & F>;
+  /** The requester or a manager closes a pending request. */
+  cancel(id: string): AsyncResult<ApprovalRequest & F>;
+  get(id: string): AsyncResult<ApprovalRequestDetail & F>;
+  /** Newest first. */
+  list(options?: ApprovalListOptions): AsyncResult<readonly (ApprovalRequest & F)[]>;
+  /** Whether the subject's latest request for the action was approved. */
+  isApproved(subject: SubjectRef, action: string): AsyncResult<boolean>;
+}
+/** The `approvals` SQL module as typed calls. */
+declare function createApprovals<S extends StandardSchemaV1 | undefined = undefined>(options: ApprovalsOptions<S>): Approvals<FieldsOf<S>>;
+//#endregion
+export { ApprovalRequestDetail as a, ApprovalStep as c, createApprovals as d, ApprovalRequest as i, Approvals as l, ApprovalDecision as n, ApprovalRequestInput as o, ApprovalListOptions as r, ApprovalStatus as s, ApprovalApprovers as t, ApprovalsOptions as u };

package/dist/arazzo/index.d.ts

@@ -1,8 +1,9 @@
-import { D as ResourceOperation, a as JsonSchema, i as JsonObject, w as ModelWorkflow, x as ModelStep } from "../model-lUafmeBQ.js";
-import { c as SpecDiagnostic, r as DocumentFormat } from "../format-CNwSjXUU.js";
-import { o as StandardLike } from "../resource-DYEtc-KN.js";
-import { A as WorkflowSource, C as ApiSource, n as DefineApiOptions } from "../api-DoWK3dTw.js";
-import { t as SPEC_PINS } from "../spec-pins-Dqpml2dZ.js";
+import { t as SPEC_PINS } from "../spec-pins-CZ2CL8YZ.js";
+import { n as DefineApiOptions } from "../api-CWhpq24a.js";
+import { D as ResourceOperation, a as JsonSchema, i as JsonObject, w as ModelWorkflow, x as ModelStep } from "../model-Btl8X9cs.js";
+import { c as SpecDiagnostic, r as DocumentFormat } from "../format-AYHceC2m.js";
+import { o as StandardLike } from "../resource-DYDEnww-.js";
+import { l as WorkflowSource, n as ApiSource } from "../options-Dm-2crCx.js";
 //#region src/arazzo/types.d.ts
 type Json = Record<string, unknown>;
 /** The Arazzo versions `arazzoFormat` renders. */
@@ -85,19 +86,22 @@ interface ArazzoSourceOptions {
 interface ArazzoFormatOptions {
   /** The OpenAPI document; its URL defaults to `openapi.json`. */
   readonly openapi?: ArazzoSourceOptions;
-  /** The AsyncAPI document channel steps use; defaults to `events` at `asyncapi.json`. */
+  /**
+   * The AsyncAPI document channel steps use; defaults to `events` at
+   * `asyncapi.json`.
+   */
   readonly asyncapi?: ArazzoSourceOptions;
 }
 /**
- * An Arazzo format whose source descriptions point at your OpenAPI and
- * AsyncAPI URLs. `arazzoFormat` is this with the defaults: `api` at the
- * model's `self` or `openapi.json`, and `events` at `asyncapi.json`.
+ * An Arazzo format whose source descriptions point at your OpenAPI and AsyncAPI
+ * URLs. `arazzoFormat` is this with the defaults: `api` at the model's `self`
+ * or `openapi.json`, and `events` at `asyncapi.json`.
  */
 export declare function createArazzoFormat(options?: ArazzoFormatOptions): DocumentFormat<"arazzo", ArazzoVersion, AnyArazzoDocument, ArazzoDocuments>;
 /**
  * Arazzo as a `DocumentFormat`, for the model's `workflows`. 1.0 is the
- * default; channel steps (AsyncAPI send and receive) and action
- * `parameters` need 1.1.
+ * default; channel steps (AsyncAPI send and receive) and action `parameters`
+ * need 1.1.
  */
 export declare const arazzoFormat: DocumentFormat<"arazzo", ArazzoVersion, AnyArazzoDocument, ArazzoDocuments>;
 //#endregion
@@ -107,28 +111,37 @@ interface BuiltinWorkflowOptions {
   readonly tables?: readonly string[];
 }
 /**
- * One workflow per cursor-paginated list: read the first page, then the
- * next one from its `nextCursor` when `hasMore` is true. Repeat the second
- * step with its own `nextCursor` to walk the rest.
+ * One workflow per cursor-paginated list: read the first page, then the next
+ * one from its `nextCursor` when `hasMore` is true. Repeat the second step with
+ * its own `nextCursor` to walk the rest.
  */
 export declare function paginationWorkflows(options?: BuiltinWorkflowOptions): WorkflowSource;
-/** One workflow per resource with `create` and `get`: create a row, then read it back by its key. */
+/**
+ * One workflow per resource with `create` and `get`: create a row, then read it
+ * back by its key.
+ */
 export declare function createThenGetWorkflows(options?: BuiltinWorkflowOptions): WorkflowSource;
 interface AuthWorkflowOptions {
   /** The operationId to call once signed in. */
   readonly call: string;
-  /** The sign-in operationId: it takes `email` and `password` and returns a token. Defaults to `signIn`. */
+  /**
+   * The sign-in operationId: it takes `email` and `password` and returns a
+   * token. Defaults to `signIn`.
+   */
   readonly signIn?: string;
-  /** JSON Pointer to the access token in the sign-in response. Defaults to `/access_token`. */
+  /**
+   * JSON Pointer to the access token in the sign-in response. Defaults to
+   * `/access_token`.
+   */
   readonly tokenPointer?: string;
   /** Defaults to `signInThen<Call>`. */
   readonly id?: string;
 }
 /**
- * Sign in, then call an operation with the access token as a bearer
- * token. A 403 Problem Details answer with code `APPROVAL_REQUIRED` ends the
- * workflow (the `approvalRequired` failure action), so a client can wait for
- * the approval instead of retrying.
+ * Sign in, then call an operation with the access token as a bearer token. A
+ * 403 Problem Details answer with code `APPROVAL_REQUIRED` ends the workflow
+ * (the `approvalRequired` failure action), so a client can wait for the
+ * approval instead of retrying.
  */
 export declare function authWorkflow(options: AuthWorkflowOptions): WorkflowSource;
 //#endregion
@@ -148,7 +161,10 @@ interface StepParameter {
   /** A literal or a runtime expression such as `$inputs.id`. */
   readonly value: unknown;
 }
-/** An Arazzo Criterion Object; `context` is required for every `type` but `simple`. */
+/**
+ * An Arazzo Criterion Object; `context` is required for every `type` but
+ * `simple`.
+ */
 interface CriterionObject {
   readonly condition: string;
   readonly context?: string;
@@ -202,20 +218,28 @@ interface WorkflowInput<Op extends string = string> {
   readonly outputs?: Readonly<Record<string, string>>;
 }
 /**
- * A workflow for `defineApi`'s `workflows`, rendered by `arazzoFormat`.
- * Steps name operations by operationId; pass the ids as `Op` (for example
- * `ResourceOperationIds<"customers">`) to type them. Rendering reports
- * unknown operationIds, steps that read outputs of later or unknown steps,
- * and channel steps outside Arazzo 1.1.
+ * A workflow for `defineApi`'s `workflows`, rendered by `arazzoFormat`. Steps
+ * name operations by operationId; pass the ids as `Op` (for example
+ * `ResourceOperationIds<"customers">`) to type them. Rendering reports unknown
+ * operationIds, steps that read outputs of later or unknown steps, and channel
+ * steps outside Arazzo 1.1.
  *
  * ```ts
  * const onboarding = defineWorkflow<ResourceOperationIds<"customers">>({
  *   id: "onboardCustomer",
  *   inputs: { type: "object", properties: { row: { type: "object" } } },
  *   steps: [
- *     { id: "create", operationId: "createCustomers", requestBody: "$inputs.row",
- *       outputs: { id: "$response.body#/id" } },
- *     { id: "get", operationId: "getCustomers", parameters: { id: "$steps.create.outputs.id" } },
+ *     {
+ *       id: "create",
+ *       operationId: "createCustomers",
+ *       requestBody: "$inputs.row",
+ *       outputs: { id: "$response.body#/id" },
+ *     },
+ *     {
+ *       id: "get",
+ *       operationId: "getCustomers",
+ *       parameters: { id: "$steps.create.outputs.id" },
+ *     },
  *   ],
  * });
  * ```
@@ -235,12 +259,11 @@ export interface ArazzoOptions<V extends ArazzoVersion = "1.0", Ref = string> ex
   readonly onDiagnostic?: (diagnostic: SpecDiagnostic) => void;
 }
 /**
- * An Arazzo document for the API's workflows: your `defineWorkflow`
- * workflows and the built-ins (`paginationWorkflows()`,
- * `createThenGetWorkflows()`, `authWorkflow()`), checked against the
- * operations the API has. Throws when building or checking the document
- * finds an error; use `defineApi(...).render(arazzoFormat)` to read every
- * finding instead.
+ * An Arazzo document for the API's workflows: your `defineWorkflow` workflows
+ * and the built-ins (`paginationWorkflows()`, `createThenGetWorkflows()`,
+ * `authWorkflow()`), checked against the operations the API has. Throws when
+ * building or checking the document finds an error; use
+ * `defineApi(...).render(arazzoFormat)` to read every finding instead.
  *
  * ```ts
  * const doc = createArazzo(betterSupabase, {

package/dist/arazzo/index.js

@@ -1,8 +1,8 @@
-import { r as isPlainObject } from "../clone-dN9XOL1K.js";
-import { t as SPEC_PINS } from "../spec-pins-S4PymRxp.js";
-import { o as defineDocumentFormat, t as defineApi } from "../api-C43_FYDp.js";
-import { c as pascal, r as safeKey, s as convertStandard } from "../build-CT6SPZkI.js";
-import "../types-BRTSpOIh.js";
+import { r as isPlainObject } from "../clone-CkG0-hlI.js";
+import { t as SPEC_PINS } from "../spec-pins-D3Tm6HJi.js";
+import { o as defineDocumentFormat, t as defineApi } from "../api-DKp2Ggz_.js";
+import { c as pascal, r as safeKey, s as convertStandard } from "../build-DCfpwg78.js";
+import "../types-BTK75521.js";
 //#region src/arazzo/format.ts
 const ARAZZO_FIELD = {
 	"1.0": SPEC_PINS.arazzo10,
@@ -177,7 +177,7 @@ function lintWorkflow(workflow, index, workflowIds, sourceNames, diagnostics) {
 	const pointer = `/workflows/${String(index)}`;
 	const stepIndex = /* @__PURE__ */ new Map();
 	const outputsOf = /* @__PURE__ */ new Map();
-	workflow.steps.forEach((step, position) => {
+	for (const [position, step] of workflow.steps.entries()) {
 		if (stepIndex.has(step.stepId)) diagnostics.push({
 			code: "arazzo-step-id-duplicate",
 			severity: "error",
@@ -186,7 +186,7 @@ function lintWorkflow(workflow, index, workflowIds, sourceNames, diagnostics) {
 		});
 		else stepIndex.set(step.stepId, position);
 		outputsOf.set(step.stepId, new Set(Object.keys(step.outputs ?? {})));
-	});
+	}
 	const inputs = inputNames(workflow.inputs);
 	const checkExpressions = (value, where, position) => {
 		const texts = [];
@@ -223,7 +223,7 @@ function lintWorkflow(workflow, index, workflowIds, sourceNames, diagnostics) {
 			});
 		}
 	};
-	workflow.steps.forEach((step, position) => {
+	for (const [position, step] of workflow.steps.entries()) {
 		const where = `${pointer}/steps/${String(position)}`;
 		if (!ID.test(step.stepId)) diagnostics.push({
 			code: "arazzo-id-invalid",
@@ -271,13 +271,13 @@ function lintWorkflow(workflow, index, workflowIds, sourceNames, diagnostics) {
 				pointer: where
 			});
 		}
-	});
+	}
 	checkExpressions(workflow.outputs, `${pointer}/outputs`);
 }
 function lintArazzo(document) {
 	const diagnostics = [];
 	const workflowIds = /* @__PURE__ */ new Set();
-	document.workflows.forEach((workflow, index) => {
+	for (const [index, workflow] of document.workflows.entries()) {
 		if (!ID.test(workflow.workflowId)) diagnostics.push({
 			code: "arazzo-id-invalid",
 			severity: "error",
@@ -291,17 +291,15 @@ function lintArazzo(document) {
 			pointer: `/workflows/${String(index)}`
 		});
 		workflowIds.add(workflow.workflowId);
-	});
+	}
 	const sourceNames = new Set(document.sourceDescriptions.map((source) => source.name));
-	document.workflows.forEach((workflow, index) => {
-		lintWorkflow(workflow, index, workflowIds, sourceNames, diagnostics);
-	});
+	for (const [index, workflow] of document.workflows.entries()) lintWorkflow(workflow, index, workflowIds, sourceNames, diagnostics);
 	return diagnostics;
 }
 /**
-* An Arazzo format whose source descriptions point at your OpenAPI and
-* AsyncAPI URLs. `arazzoFormat` is this with the defaults: `api` at the
-* model's `self` or `openapi.json`, and `events` at `asyncapi.json`.
+* An Arazzo format whose source descriptions point at your OpenAPI and AsyncAPI
+* URLs. `arazzoFormat` is this with the defaults: `api` at the model's `self`
+* or `openapi.json`, and `events` at `asyncapi.json`.
 */
 function createArazzoFormat(options = {}) {
 	return defineDocumentFormat({
@@ -324,8 +322,8 @@ function createArazzoFormat(options = {}) {
 }
 /**
 * Arazzo as a `DocumentFormat`, for the model's `workflows`. 1.0 is the
-* default; channel steps (AsyncAPI send and receive) and action
-* `parameters` need 1.1.
+* default; channel steps (AsyncAPI send and receive) and action `parameters`
+* need 1.1.
 */
 const arazzoFormat = createArazzoFormat();
 //#endregion
@@ -339,9 +337,9 @@ const inputParameter = (parameter) => ({
 });
 const pathParameter = (operation) => operation.parameters.find((parameter) => parameter.in === "path")?.name;
 /**
-* One workflow per cursor-paginated list: read the first page, then the
-* next one from its `nextCursor` when `hasMore` is true. Repeat the second
-* step with its own `nextCursor` to walk the rest.
+* One workflow per cursor-paginated list: read the first page, then the next
+* one from its `nextCursor` when `hasMore` is true. Repeat the second step with
+* its own `nextCursor` to walk the rest.
 */
 function paginationWorkflows(options = {}) {
 	return (operations) => tablesOf(operations).filter((table) => !options.tables || options.tables.includes(table)).flatMap((table) => {
@@ -404,7 +402,10 @@ function paginationWorkflows(options = {}) {
 		}];
 	});
 }
-/** One workflow per resource with `create` and `get`: create a row, then read it back by its key. */
+/**
+* One workflow per resource with `create` and `get`: create a row, then read it
+* back by its key.
+*/
 function createThenGetWorkflows(options = {}) {
 	return (operations) => tablesOf(operations).filter((table) => !options.tables || options.tables.includes(table)).flatMap((table) => {
 		const create = resourceOf(operations, table, "create");
@@ -444,10 +445,10 @@ function createThenGetWorkflows(options = {}) {
 	});
 }
 /**
-* Sign in, then call an operation with the access token as a bearer
-* token. A 403 Problem Details answer with code `APPROVAL_REQUIRED` ends the
-* workflow (the `approvalRequired` failure action), so a client can wait for
-* the approval instead of retrying.
+* Sign in, then call an operation with the access token as a bearer token. A
+* 403 Problem Details answer with code `APPROVAL_REQUIRED` ends the workflow
+* (the `approvalRequired` failure action), so a client can wait for the
+* approval instead of retrying.
 */
 function authWorkflow(options) {
 	const signIn = options.signIn ?? "signIn";
@@ -556,20 +557,28 @@ function stepOf(step) {
 	};
 }
 /**
-* A workflow for `defineApi`'s `workflows`, rendered by `arazzoFormat`.
-* Steps name operations by operationId; pass the ids as `Op` (for example
-* `ResourceOperationIds<"customers">`) to type them. Rendering reports
-* unknown operationIds, steps that read outputs of later or unknown steps,
-* and channel steps outside Arazzo 1.1.
+* A workflow for `defineApi`'s `workflows`, rendered by `arazzoFormat`. Steps
+* name operations by operationId; pass the ids as `Op` (for example
+* `ResourceOperationIds<"customers">`) to type them. Rendering reports unknown
+* operationIds, steps that read outputs of later or unknown steps, and channel
+* steps outside Arazzo 1.1.
 *
 * ```ts
 * const onboarding = defineWorkflow<ResourceOperationIds<"customers">>({
 *   id: "onboardCustomer",
 *   inputs: { type: "object", properties: { row: { type: "object" } } },
 *   steps: [
-*     { id: "create", operationId: "createCustomers", requestBody: "$inputs.row",
-*       outputs: { id: "$response.body#/id" } },
-*     { id: "get", operationId: "getCustomers", parameters: { id: "$steps.create.outputs.id" } },
+*     {
+*       id: "create",
+*       operationId: "createCustomers",
+*       requestBody: "$inputs.row",
+*       outputs: { id: "$response.body#/id" },
+*     },
+*     {
+*       id: "get",
+*       operationId: "getCustomers",
+*       parameters: { id: "$steps.create.outputs.id" },
+*     },
 *   ],
 * });
 * ```
@@ -587,12 +596,11 @@ function defineWorkflow(workflow) {
 //#endregion
 //#region src/arazzo/index.ts
 /**
-* An Arazzo document for the API's workflows: your `defineWorkflow`
-* workflows and the built-ins (`paginationWorkflows()`,
-* `createThenGetWorkflows()`, `authWorkflow()`), checked against the
-* operations the API has. Throws when building or checking the document
-* finds an error; use `defineApi(...).render(arazzoFormat)` to read every
-* finding instead.
+* An Arazzo document for the API's workflows: your `defineWorkflow` workflows
+* and the built-ins (`paginationWorkflows()`, `createThenGetWorkflows()`,
+* `authWorkflow()`), checked against the operations the API has. Throws when
+* building or checking the document finds an error; use
+* `defineApi(...).render(arazzoFormat)` to read every finding instead.
 *
 * ```ts
 * const doc = createArazzo(betterSupabase, {

package/dist/assistant-D1yev_fR.d.ts

@@ -0,0 +1,157 @@
+import { b as DbError } from "./result-C6jDfedy.js";
+import { i as AiMessage } from "./message-Bg4TKA12.js";
+import { E as AiRunStatus, F as AiUserMessageTrigger, _ as AiModerationAction, i as AiChat, u as AiChatRecord } from "./ai-chat-DBxEz3o1.js";
+import { n as GatewayOptions } from "./gateway-options-BlVCqgb8.js";
+import { o as StreamStore } from "./store-o0HwYXl8.js";
+import { i as CostBackfillPayload, t as AiUsage } from "./gateway-DI8dbOml.js";
+import { LanguageModelUsage, ModelMessage, UIMessage, UIMessageChunk, UIMessageStreamOnEndCallback } from "ai";
+//#region src/ai-sdk/chat/assistant.d.ts
+/** Who asks, for one request. */
+interface AssistantContext {
+  /**
+   * The chat block for this request: the user's transport, and a service
+   * transport (`service`) for the writes only the server makes.
+   */
+  readonly chats: AiChat;
+  readonly userId: string;
+  readonly organizationId: string;
+  /**
+   * Keeps the function alive until the answer is stored, after the response is
+   * sent: `after` in Next.js, `ctx.waitUntil` on Workers and Vercel.
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
+}
+/** What `run` gets to generate one answer. */
+interface AssistantRunArgs {
+  readonly chat: AiChatRecord;
+  /** The model the request may use, after the catalog check. */
+  readonly model: string;
+  readonly messages: ModelMessage[];
+  /** The history the model sees, as UI messages. */
+  readonly uiMessages: UIMessage[];
+  /** Aborted by `stop()`; pass it to `streamText` or `agent.stream`. */
+  readonly abortSignal: AbortSignal;
+  /** Spend attribution for the AI Gateway (`gatewayOptions`). */
+  readonly providerOptions: {
+    readonly gateway: GatewayOptions;
+  };
+  readonly context: AssistantContext;
+}
+/** The part of a `streamText` or `agent.stream` result the assistant reads. */
+interface AssistantRunResult {
+  toUIMessageStream(options: {
+    originalMessages: UIMessage[];
+    generateMessageId: () => string;
+    onEnd: UIMessageStreamOnEndCallback<UIMessage>;
+    onError?: (error: unknown) => string;
+  }): ReadableStream<UIMessageChunk>;
+  readonly totalUsage?: PromiseLike<LanguageModelUsage>;
+  readonly providerMetadata?: PromiseLike<unknown>;
+}
+/** The verdict of a moderation hook. */
+interface AssistantModeration {
+  readonly action: AiModerationAction;
+  readonly category: string;
+  readonly score?: number;
+}
+/** What `onFinish` gets once the answer is stored. */
+interface AssistantFinish {
+  readonly chat: AiChatRecord;
+  readonly message: UIMessage;
+  readonly status: AiRunStatus;
+  readonly model: string;
+  readonly usage: AiUsage | undefined;
+  readonly context: AssistantContext;
+}
+interface AssistantOptions {
+  /** Where the answer's stream is kept, so a reload resumes it. */
+  readonly streams: StreamStore;
+  /** Starts the generation: `agent.stream(...)` or `streamText(...)`. */
+  readonly run: (args: AssistantRunArgs) => AssistantRunResult | PromiseLike<AssistantRunResult>;
+  /** The model when neither the request nor the chat names an allowed one. */
+  readonly defaultModel: string;
+  /**
+   * The quota check before a generation (`usageQuota(usage, meter)`); an error
+   * answers 429.
+   */
+  readonly quota?: (organizationId: string) => Promise<DbError | undefined>;
+  /** Checks the user's message; `block` answers 403, others are recorded. */
+  readonly moderate?: (input: {
+    readonly message: AiMessage;
+    readonly chat: AiChatRecord;
+  }) => Promise<AssistantModeration | undefined>;
+  /**
+   * Called with the cost backfill payload when the gateway hasn't reported a
+   * cost yet.
+   */
+  readonly enqueueCostBackfill?: (payload: CostBackfillPayload) => Promise<unknown>;
+  /** Called after the answer is stored, such as to record usage. */
+  readonly onFinish?: (finish: AssistantFinish) => void | Promise<void>;
+  /**
+   * What the stream is kept for: seconds or a Postgres interval. Defaults to
+   * one day.
+   */
+  readonly streamTtl?: number | string;
+  /** The `feature` tag of the gateway options. Defaults to `chat`. */
+  readonly feature?: string;
+  /** Turns a stream error into the message the client sees. */
+  readonly onError?: (error: unknown) => string;
+  /** Makes message and stream ids. Defaults to `crypto.randomUUID()`. */
+  readonly generateId?: () => string;
+}
+/** The body `useAssistant` sends. */
+interface AssistantRequestBody {
+  /** The chat id; the client may make it, and the chat is created on first use. */
+  readonly id: string;
+  readonly message: UIMessage;
+  readonly trigger?: AiUserMessageTrigger;
+  /** For `regenerate-message`, the answer to write again. */
+  readonly messageId?: string;
+  readonly model?: string;
+}
+/** A checked and stored user turn, ready for a model: what `prepare` returns. */
+interface AssistantTurn {
+  readonly chat: AiChatRecord;
+  /** The model the request may use, after the catalog check. */
+  readonly model: string;
+  /** The stored user message, which the answer is saved under. */
+  readonly parentId: string;
+  /** The history the model sees, as UI messages. */
+  readonly uiMessages: UIMessage[];
+  readonly messages: ModelMessage[];
+  /** Spend attribution for the AI Gateway (`gatewayOptions`). */
+  readonly providerOptions: {
+    readonly gateway: GatewayOptions;
+  };
+}
+interface Assistant {
+  /** Stores the user's message, starts the answer and streams it (SSE). */
+  respond(request: Request, context: AssistantContext): Promise<Response>;
+  /**
+   * The checks and writes before a generation, without one: parses the body
+   * `useAssistant` sends, creates the chat on first use, picks the model,
+   * moderates, checks the quota, stores the user's message and loads the
+   * history. Returns a problem response when one of them fails.
+   */
+  prepare(body: unknown, context: AssistantContext): Promise<AssistantTurn | Response>;
+  /** The running answer of `chatId` from the start, or 204 when none runs. */
+  resume(chatId: string, context: AssistantContext, options?: {
+    readonly fromIdx?: number;
+    readonly signal?: AbortSignal;
+  }): Promise<Response>;
+  /**
+   * Asks the running answer to stop: 204 whether or not one runs, a problem
+   * when the user may not.
+   */
+  stop(chatId: string, context: AssistantContext): Promise<Response>;
+}
+/**
+ * A chat route for the AI SDK on the `ai-chat` block: `respond` stores the
+ * user's message, picks an allowed model, checks the quota, claims the chat's
+ * answer, runs the model and streams it while keeping a copy in the stream
+ * store; the answer and its usage are stored when it ends, even after the
+ * client left. `resume` replays it after a reload, `stop` ends it.
+ */
+declare function createAssistant(options: AssistantOptions): Assistant;
+//#endregion
+export { AssistantOptions as a, AssistantRunResult as c, AssistantModeration as i, AssistantTurn as l, AssistantContext as n, AssistantRequestBody as o, AssistantFinish as r, AssistantRunArgs as s, Assistant as t, createAssistant as u };