import * as Y from 'yjs';
import { LanguageModel, ToolSet, StreamTextResult, streamText, ModelMessage } from 'ai';
import { Hono, Context, ErrorHandler } from 'hono';
import * as zod_v4_core from 'zod/v4/core';
import * as zod from 'zod';
import * as better_auth_plugins from 'better-auth/plugins';
import * as better_auth from 'better-auth';
import { betterAuth } from 'better-auth';

/**
 * Wire protocol constants.
 *
 * The JSON WebSocket protocol uses dotted string identifiers (e.g.
 * `"records.query"`) as the `type` discriminator. All message types are
 * grouped under a single `MSG` object so imports stay tidy:
 *
 *     import { MSG, dispatch, clientBuild } from 'deepspace'
 *
 *     dispatch<ServerMessage>(raw, {
 *     })
 *
 * Each key's value is the on-wire string — grep-friendly, self-
 * documenting, and infinite per namespace. Adding a new message is one
 * line here plus one arm in the discriminated union in `./messages.ts`.
 *
 * Yjs binary protocol constants (`MSG_YJS_SYNC`, `MSG_YJS_AWARENESS`) are
 * intentionally kept numeric and separate from `MSG` — they ride a
 * binary WebSocket frame format and aren't part of the JSON dispatcher.
 */
declare const MSG: {
    readonly SUBSCRIBE: "core.subscribe";
    readonly UNSUBSCRIBE: "core.unsubscribe";
    readonly QUERY_RESULT: "core.query_result";
    readonly RECORD_CHANGE: "core.record_change";
    readonly PUT: "core.put";
    readonly DELETE: "core.delete";
    readonly ERROR: "core.error";
    readonly USER_INFO: "user.info";
    readonly USER_LIST: "user.list";
    readonly SET_ROLE: "user.set_role";
    readonly USER_UPDATE: "user.update";
    readonly AUTH: "auth";
    readonly YJS_JOIN: "yjs.join";
    readonly YJS_LEAVE: "yjs.leave";
    readonly ACK: "records.ack";
    readonly LIST_SCHEMAS: "records.list_schemas";
    readonly RESUBSCRIBE: "records.resubscribe";
    readonly CANVAS_SHAPES: "canvas.shapes";
    readonly CANVAS_ADD: "canvas.add";
    readonly CANVAS_MOVE: "canvas.move";
    readonly CANVAS_RESIZE: "canvas.resize";
    readonly CANVAS_DELETE: "canvas.delete";
    readonly CANVAS_UPDATE: "canvas.update";
    readonly CANVAS_VIEWPORT: "canvas.viewport";
    readonly CANVAS_UNDO: "canvas.undo";
    readonly CANVAS_REDO: "canvas.redo";
    readonly CRON_TASKS: "cron.tasks";
    readonly CRON_HISTORY: "cron.history";
    readonly CRON_TRIGGER: "cron.trigger";
    readonly CRON_PAUSE: "cron.pause";
    readonly CRON_RESUME: "cron.resume";
    readonly CRON_STATUS: "cron.status";
    readonly CRON_ACK: "cron.ack";
    readonly JOB_ENQUEUE: "job.enqueue";
    readonly JOB_CANCEL: "job.cancel";
    readonly JOB_RETRY: "job.retry";
    readonly JOB_UPDATE: "job.update";
    readonly PRESENCE_SYNC: "presence.sync";
    readonly PRESENCE_JOIN: "presence.join";
    readonly PRESENCE_LEAVE: "presence.leave";
    readonly PRESENCE_UPDATE: "presence.update";
};
/**
 * Type of any message type constant — the union of every string literal
 * stored in `MSG`. Useful when declaring functions that accept "any known
 * message type" without enumerating all 54 strings by hand.
 */
type MsgType = (typeof MSG)[keyof typeof MSG];
/** Outer envelope id for binary-framed yjs sync messages. Varuint-encoded. */
declare const MSG_YJS_SYNC = 22;
/** Outer envelope id for binary-framed yjs awareness messages. Varuint-encoded. */
declare const MSG_YJS_AWARENESS = 23;
/** Role assigned to unauthenticated WebSocket connections */
declare const ROLE_ANONYMOUS = "viewer";
/** Prefix `base-room` mints anonymous socket ids with. */
declare const ANONYMOUS_USER_ID_PREFIX = "anon-";
/** The one test for an anonymous socket identity — `ROLE_ANONYMOUS` cannot be
 *  it, since authenticated users can legitimately hold the same role name. */
declare function isAnonymousUserId(userId: string): boolean;
/** Default role for newly registered authenticated users */
declare const ROLE_DEFAULT = "member";
/** Admin role */
declare const ROLE_ADMIN = "admin";
/**
 * Reported when a record id resolves to nothing.
 *
 * This crosses the DO boundary as a response body and callers branch on it,
 * so it is a contract rather than prose. `getChat` in particular treats it as
 * "no such chat" and returns null — the same answer it gives for a chat owned
 * by someone else, which is what stops chat ids being enumerable. If a room
 * reworded this independently, a miss would start throwing while a cross-user
 * hit kept returning null, and that difference is an existence oracle.
 */
declare const RECORD_NOT_FOUND = "Record not found";

/**
 * Typed wire-protocol layer — discriminated unions, typed builders, and a
 * type-safe dispatcher for every `MSG.*` the SDK understands.
 *
 * Why this exists
 * ---------------
 *
 * The string `MSG.*` constants in `./constants.ts` are the authoritative
 * wire protocol, but using them directly is error-prone: a typo picks the
 * wrong message with the wrong payload shape and fails silently at
 * runtime. This module pairs every constant with its payload type, so
 * that:
 *
 *   1. Building a message with `clientBuild.canvasAdd(...)` is payload-
 *      checked at the call site — the compiler refuses to ship a wrong
 *      shape.
 *
 *   2. Parsing an inbound message via `dispatch(raw, handlers)` narrows the
 *      payload type inside each handler automatically, replacing the
 *      unsafe `switch (msg.type) { case MSG.X: (payload as any).foo }`
 *      pattern.
 *
 *   3. Tightening `BaseRoom.sendTo` / `BaseRoom.broadcast` /
 *      `HandlerContext.send` / `SubscriptionContext.send` to accept
 *      `ServerMessage` turns the type layer into enforcement: any room
 *      that ships a payload inconsistent with its declared arm fails to
 *      compile. Without that, the discriminated union is documentation,
 *      not contract.
 *
 *   4. Adding a new `MSG.*` is localized: one entry in the discriminated
 *      union, one builder function, one handler key in every dispatcher
 *      that cares. No grep-and-fix across the codebase.
 *
 *   5. Apps can extend the SDK protocol without forking: `dispatch<M>` is
 *      generic over any `M extends ProtocolMessage`, and builders are
 *      plain objects so apps compose via spread (`{ ...clientBuild,
 *      myMessage: ... }`).
 *
 * Direction split
 * ---------------
 *
 * Some message types carry different payloads depending on who's sending.
 * `MSG.RECORDS_RESUBSCRIBE`, for example, is `{}` when the client asks to
 * but `{ state, tick }` when the server broadcasts the start event.
 * `MSG.CANVAS_ADD` is a flat shape dict on the way in and a `{ shape }`
 * wrapper on the way out. Modelling these with one union would force
 * handlers to juggle a union payload — clunky and error-prone. Instead we
 * split by direction:
 *
 *   - `ClientMessage` — what the client sends to the server
 *   - `ServerMessage` — what the server sends to the client
 *   - `ProtocolMessage = ClientMessage | ServerMessage` (for code that
 *     really doesn't care — avoid when possible)
 *
 * Each side gets its own builder (`clientBuild` / `serverBuild`) and each
 * side's dispatcher is parameterised with the union it expects.
 *
 * Payload strictness
 * ------------------
 *
 * Where payload shapes are stable + narrow (ids, flags), we type them
 * precisely. Where they're opaque or escape the protocol layer (record
 * data blobs, Yjs binary frames, canvas shapes), we use `unknown` and
 * defer narrowing to the caller. This is intentional: over-typing opaque
 * payloads would require the protocol layer to import application types
 * and defeat the "thin wire contract" goal.
 */

/**
 * The outer shape of every wire message. `T` is the string discriminator
 * (e.g. `"canvas.add"`) — keeping it as a generic literal type lets the
 * discriminated-union narrowing in `dispatch()` pick the right payload.
 *
 * Callers extending the protocol should pass a string-literal type for
 * `T`, not the widened `string`. `BaseMessage<string, P>` collapses the
 * discriminated union and handler-map key inference falls back to a
 * single untyped `string` key, losing all narrowing.
 */
interface BaseMessage<T extends string, P> {
    type: T;
    payload: P;
}
/** Matches when a payload is intentionally empty — `{}` on the wire. */
type EmptyPayload = Record<string, never>;
/**
 * Every message the client can legitimately send. Extend in app code with
 * a string-literal union arm:
 *
 *     type MyClientMessage = ClientMessage | BaseMessage<'myapp.foo', { x: number }>
 */
type ClientMessage = BaseMessage<typeof MSG.SUBSCRIBE, {
    subscriptionId: string;
    query: unknown;
}> | BaseMessage<typeof MSG.UNSUBSCRIBE, {
    subscriptionId: string;
}> | BaseMessage<typeof MSG.PUT, {
    collection: string;
    recordId: string;
    data: Record<string, unknown>;
    requestId?: string;
}> | BaseMessage<typeof MSG.DELETE, {
    collection: string;
    recordId: string;
    requestId?: string;
}> | BaseMessage<typeof MSG.USER_LIST, EmptyPayload> | BaseMessage<typeof MSG.SET_ROLE, {
    userId: string;
    role: string;
}> | BaseMessage<typeof MSG.USER_UPDATE, EmptyPayload> | BaseMessage<typeof MSG.LIST_SCHEMAS, EmptyPayload> | BaseMessage<typeof MSG.YJS_JOIN, {
    collection: string;
    recordId: string;
    fieldName: string;
}> | BaseMessage<typeof MSG.YJS_LEAVE, {
    collection: string;
    recordId: string;
    fieldName: string;
}> | BaseMessage<typeof MSG.CANVAS_ADD, unknown> | BaseMessage<typeof MSG.CANVAS_MOVE, {
    shapeId: string;
    x: number;
    y: number;
}> | BaseMessage<typeof MSG.CANVAS_RESIZE, {
    shapeId: string;
    width: number;
    height: number;
    x?: number;
    y?: number;
}> | BaseMessage<typeof MSG.CANVAS_DELETE, {
    shapeId: string;
}> | BaseMessage<typeof MSG.CANVAS_UPDATE, {
    shapeId: string;
    props: Record<string, unknown>;
}> | BaseMessage<typeof MSG.CANVAS_VIEWPORT, unknown> | BaseMessage<typeof MSG.CANVAS_UNDO, EmptyPayload> | BaseMessage<typeof MSG.CANVAS_REDO, EmptyPayload> | BaseMessage<typeof MSG.CRON_TRIGGER, {
    taskName: string;
    requestId?: string;
}> | BaseMessage<typeof MSG.CRON_PAUSE, {
    taskName: string;
    requestId?: string;
}> | BaseMessage<typeof MSG.CRON_RESUME, {
    taskName: string;
    requestId?: string;
}> | BaseMessage<typeof MSG.JOB_ENQUEUE, {
    requestId: string;
    type: string;
    payload?: unknown;
    maxAttempts?: number;
}> | BaseMessage<typeof MSG.JOB_CANCEL, {
    jobId: string;
}> | BaseMessage<typeof MSG.JOB_RETRY, {
    jobId: string;
}> | BaseMessage<typeof MSG.PRESENCE_UPDATE, Record<string, unknown>>;
/**
 * Every message the server can send. Room and handler `send` / `broadcast`
 * signatures are tightened to this union so outbound payloads are
 * compile-checked against the wire contract. As with `ClientMessage`,
 * extend via a string-literal union arm in app code when adding new
 * server-side broadcasts.
 */
type ServerMessage = BaseMessage<typeof MSG.QUERY_RESULT, {
    subscriptionId: string;
    records: unknown[];
}> | BaseMessage<typeof MSG.RECORD_CHANGE, {
    collection: string;
    record: unknown;
    changeType: 'create' | 'update' | 'delete';
}> | BaseMessage<typeof MSG.ERROR, {
    error: string;
    subscriptionId?: string;
}> | BaseMessage<typeof MSG.ACK, {
    requestId: string;
    success: true;
    recordId?: string;
} | {
    requestId: string;
    success: false;
    error: string;
}> | BaseMessage<typeof MSG.RESUBSCRIBE, EmptyPayload> | BaseMessage<typeof MSG.LIST_SCHEMAS, {
    schemas: unknown;
}> | BaseMessage<typeof MSG.AUTH, {
    canWrite: boolean;
}> | BaseMessage<typeof MSG.USER_INFO, unknown> | BaseMessage<typeof MSG.USER_LIST, {
    users: unknown[];
}> | BaseMessage<typeof MSG.YJS_JOIN, {
    collection: string;
    recordId: string;
    fieldName: string;
    canWrite: boolean;
}> | BaseMessage<typeof MSG.CANVAS_SHAPES, {
    shapes: unknown[];
    viewports: unknown[];
}> | BaseMessage<typeof MSG.CANVAS_ADD, {
    shape: unknown;
}> | BaseMessage<typeof MSG.CANVAS_MOVE, {
    shapeId: string;
    x: number;
    y: number;
}> | BaseMessage<typeof MSG.CANVAS_RESIZE, {
    shapeId: string;
    width: number;
    height: number;
    x?: number;
    y?: number;
}> | BaseMessage<typeof MSG.CANVAS_DELETE, {
    shapeId: string;
}> | BaseMessage<typeof MSG.CANVAS_UPDATE, {
    shapeId: string;
    props: Record<string, unknown>;
}> | BaseMessage<typeof MSG.CANVAS_VIEWPORT, {
    viewport: unknown;
} | {
    userId: string;
    removed: true;
}> | BaseMessage<typeof MSG.CRON_TASKS, {
    tasks: unknown;
}> | BaseMessage<typeof MSG.CRON_HISTORY, {
    history: unknown;
}> | BaseMessage<typeof MSG.CRON_STATUS, {
    tasks: unknown;
    recentHistory: unknown;
}> | BaseMessage<typeof MSG.CRON_ACK, {
    requestId: string;
    taskName: string;
    ok: true;
} | {
    requestId: string;
    taskName?: string;
    ok: false;
    reason: 'read_only' | 'unknown_task' | 'failed';
    error?: string;
}> | BaseMessage<typeof MSG.JOB_UPDATE, {
    kind: 'snapshot' | 'enqueued' | 'progress' | 'succeeded' | 'failed' | 'canceled' | 'retried';
    job?: unknown;
    jobs?: unknown[];
    /** Echoes the enqueue requestId when the update is the enqueue ack. */
    requestId?: string;
}> | BaseMessage<typeof MSG.PRESENCE_SYNC, {
    peers: unknown[];
}> | BaseMessage<typeof MSG.PRESENCE_JOIN, {
    peer: unknown;
}> | BaseMessage<typeof MSG.PRESENCE_LEAVE, {
    userId: string;
}> | BaseMessage<typeof MSG.PRESENCE_UPDATE, {
    userId: string;
    state: Record<string, unknown>;
}>;
/**
 * Any wire message, regardless of direction. Use this only when the code
 * path genuinely doesn't care — otherwise pick `ClientMessage` or
 * `ServerMessage` so the handler's payload type is narrower.
 */
type ProtocolMessage = ClientMessage | ServerMessage;
/** Factories for every client → server message. */
declare const clientBuild: {
    subscribe: (subscriptionId: string, query: unknown) => {
        readonly type: "core.subscribe";
        readonly payload: {
            readonly subscriptionId: string;
            readonly query: unknown;
        };
    };
    unsubscribe: (subscriptionId: string) => {
        readonly type: "core.unsubscribe";
        readonly payload: {
            readonly subscriptionId: string;
        };
    };
    put: (collection: string, recordId: string, data: Record<string, unknown>, requestId?: string) => {
        readonly type: "core.put";
        readonly payload: {
            readonly collection: string;
            readonly recordId: string;
            readonly data: Record<string, unknown>;
            readonly requestId: string | undefined;
        };
    };
    remove: (collection: string, recordId: string, requestId?: string) => {
        readonly type: "core.delete";
        readonly payload: {
            readonly collection: string;
            readonly recordId: string;
            readonly requestId: string | undefined;
        };
    };
    userList: () => {
        readonly type: "user.list";
        readonly payload: EmptyPayload;
    };
    setRole: (userId: string, role: string) => {
        readonly type: "user.set_role";
        readonly payload: {
            readonly userId: string;
            readonly role: string;
        };
    };
    userUpdate: () => {
        readonly type: "user.update";
        readonly payload: EmptyPayload;
    };
    listSchemas: () => {
        readonly type: "records.list_schemas";
        readonly payload: EmptyPayload;
    };
    yjsJoin: (collection: string, recordId: string, fieldName: string) => {
        readonly type: "yjs.join";
        readonly payload: {
            readonly collection: string;
            readonly recordId: string;
            readonly fieldName: string;
        };
    };
    yjsLeave: (collection: string, recordId: string, fieldName: string) => {
        readonly type: "yjs.leave";
        readonly payload: {
            readonly collection: string;
            readonly recordId: string;
            readonly fieldName: string;
        };
    };
    canvasAdd: (shape: Record<string, unknown>) => {
        readonly type: "canvas.add";
        readonly payload: Record<string, unknown>;
    };
    canvasMove: (shapeId: string, x: number, y: number) => {
        readonly type: "canvas.move";
        readonly payload: {
            readonly shapeId: string;
            readonly x: number;
            readonly y: number;
        };
    };
    canvasResize: (shapeId: string, width: number, height: number, x?: number, y?: number) => {
        readonly type: "canvas.resize";
        readonly payload: {
            readonly shapeId: string;
            readonly width: number;
            readonly height: number;
            readonly x: number | undefined;
            readonly y: number | undefined;
        };
    };
    canvasDelete: (shapeId: string) => {
        readonly type: "canvas.delete";
        readonly payload: {
            readonly shapeId: string;
        };
    };
    canvasUpdate: (shapeId: string, props: Record<string, unknown>) => {
        readonly type: "canvas.update";
        readonly payload: {
            readonly shapeId: string;
            readonly props: Record<string, unknown>;
        };
    };
    canvasViewport: (viewport: Record<string, unknown>) => {
        readonly type: "canvas.viewport";
        readonly payload: Record<string, unknown>;
    };
    canvasUndo: () => {
        readonly type: "canvas.undo";
        readonly payload: EmptyPayload;
    };
    canvasRedo: () => {
        readonly type: "canvas.redo";
        readonly payload: EmptyPayload;
    };
    cronTrigger: (taskName: string, requestId?: string) => {
        readonly type: "cron.trigger";
        readonly payload: {
            readonly taskName: string;
            readonly requestId: string | undefined;
        };
    };
    cronPause: (taskName: string, requestId?: string) => {
        readonly type: "cron.pause";
        readonly payload: {
            readonly taskName: string;
            readonly requestId: string | undefined;
        };
    };
    cronResume: (taskName: string, requestId?: string) => {
        readonly type: "cron.resume";
        readonly payload: {
            readonly taskName: string;
            readonly requestId: string | undefined;
        };
    };
    jobEnqueue: (requestId: string, type: string, payload?: unknown, maxAttempts?: number) => {
        readonly type: "job.enqueue";
        readonly payload: {
            readonly requestId: string;
            readonly type: string;
            readonly payload: unknown;
            readonly maxAttempts: number | undefined;
        };
    };
    jobCancel: (jobId: string) => {
        readonly type: "job.cancel";
        readonly payload: {
            readonly jobId: string;
        };
    };
    jobRetry: (jobId: string) => {
        readonly type: "job.retry";
        readonly payload: {
            readonly jobId: string;
        };
    };
    presenceUpdate: (state: Record<string, unknown>) => {
        readonly type: "presence.update";
        readonly payload: Record<string, unknown>;
    };
};
/** Factories for every server → client message. Used by room DOs and
 *  handler modules so server broadcasts are payload-checked too. Opaque
 *  slots (`record`, `shape`, `peer`, etc.) take `unknown` so concrete
 *  domain types — `RecordResult`, `CanvasShape`, `MediaPeer` — can be
 *  passed without casts. */
declare const serverBuild: {
    queryResult: (subscriptionId: string, records: unknown[]) => {
        readonly type: "core.query_result";
        readonly payload: {
            readonly subscriptionId: string;
            readonly records: unknown[];
        };
    };
    recordChange: (collection: string, record: unknown, changeType: "create" | "update" | "delete") => {
        readonly type: "core.record_change";
        readonly payload: {
            readonly collection: string;
            readonly record: unknown;
            readonly changeType: "create" | "update" | "delete";
        };
    };
    error: (error: string, subscriptionId?: string) => {
        readonly type: "core.error";
        readonly payload: {
            readonly error: string;
            readonly subscriptionId: string | undefined;
        };
    };
    ackSuccess: (requestId: string, recordId?: string) => {
        readonly type: "records.ack";
        readonly payload: {
            readonly requestId: string;
            readonly success: true;
            readonly recordId: string | undefined;
        };
    };
    ackFailure: (requestId: string, error: string) => {
        readonly type: "records.ack";
        readonly payload: {
            readonly requestId: string;
            readonly success: false;
            readonly error: string;
        };
    };
    resubscribe: () => {
        readonly type: "records.resubscribe";
        readonly payload: EmptyPayload;
    };
    schemas: (schemas: unknown) => {
        readonly type: "records.list_schemas";
        readonly payload: {
            readonly schemas: unknown;
        };
    };
    userInfo: (user: unknown) => {
        readonly type: "user.info";
        readonly payload: unknown;
    };
    userList: (users: unknown[]) => {
        readonly type: "user.list";
        readonly payload: {
            readonly users: unknown[];
        };
    };
    yjsJoin: (collection: string, recordId: string, fieldName: string, canWrite: boolean) => {
        readonly type: "yjs.join";
        readonly payload: {
            readonly collection: string;
            readonly recordId: string;
            readonly fieldName: string;
            readonly canWrite: boolean;
        };
    };
    canvasShapes: (shapes: unknown[], viewports: unknown[]) => {
        readonly type: "canvas.shapes";
        readonly payload: {
            readonly shapes: unknown[];
            readonly viewports: unknown[];
        };
    };
    canvasAdd: (shape: unknown) => {
        readonly type: "canvas.add";
        readonly payload: {
            readonly shape: unknown;
        };
    };
    canvasMove: (shapeId: string, x: number, y: number) => {
        readonly type: "canvas.move";
        readonly payload: {
            readonly shapeId: string;
            readonly x: number;
            readonly y: number;
        };
    };
    canvasResize: (shapeId: string, width: number, height: number, x?: number, y?: number) => {
        readonly type: "canvas.resize";
        readonly payload: {
            readonly shapeId: string;
            readonly width: number;
            readonly height: number;
            readonly x: number | undefined;
            readonly y: number | undefined;
        };
    };
    canvasDelete: (shapeId: string) => {
        readonly type: "canvas.delete";
        readonly payload: {
            readonly shapeId: string;
        };
    };
    canvasUpdate: (shapeId: string, props: Record<string, unknown>) => {
        readonly type: "canvas.update";
        readonly payload: {
            readonly shapeId: string;
            readonly props: Record<string, unknown>;
        };
    };
    canvasViewport: (viewport: unknown) => {
        readonly type: "canvas.viewport";
        readonly payload: {
            readonly viewport: unknown;
        };
    };
    canvasViewportRemoved: (userId: string) => {
        readonly type: "canvas.viewport";
        readonly payload: {
            readonly userId: string;
            readonly removed: true;
        };
    };
    cronTasks: (tasks: unknown) => {
        readonly type: "cron.tasks";
        readonly payload: {
            readonly tasks: unknown;
        };
    };
    cronHistory: (history: unknown) => {
        readonly type: "cron.history";
        readonly payload: {
            readonly history: unknown;
        };
    };
    cronStatus: (tasks: unknown, recentHistory: unknown) => {
        readonly type: "cron.status";
        readonly payload: {
            readonly tasks: unknown;
            readonly recentHistory: unknown;
        };
    };
    cronAckSuccess: (requestId: string, taskName: string) => {
        readonly type: "cron.ack";
        readonly payload: {
            readonly requestId: string;
            readonly taskName: string;
            readonly ok: true;
        };
    };
    cronAckFailure: (requestId: string, reason: "read_only" | "unknown_task" | "failed", error?: string, taskName?: string) => {
        readonly type: "cron.ack";
        readonly payload: {
            readonly requestId: string;
            readonly taskName: string | undefined;
            readonly ok: false;
            readonly reason: "read_only" | "unknown_task" | "failed";
            readonly error: string | undefined;
        };
    };
    jobSnapshot: (jobs: unknown[]) => {
        readonly type: "job.update";
        readonly payload: {
            readonly kind: "snapshot";
            readonly jobs: unknown[];
        };
    };
    jobEnqueued: (job: unknown, requestId?: string) => {
        readonly type: "job.update";
        readonly payload: {
            readonly kind: "enqueued";
            readonly job: unknown;
            readonly requestId: string | undefined;
        };
    };
    jobProgress: (job: unknown) => {
        readonly type: "job.update";
        readonly payload: {
            readonly kind: "progress";
            readonly job: unknown;
        };
    };
    jobSucceeded: (job: unknown) => {
        readonly type: "job.update";
        readonly payload: {
            readonly kind: "succeeded";
            readonly job: unknown;
        };
    };
    jobFailed: (job: unknown) => {
        readonly type: "job.update";
        readonly payload: {
            readonly kind: "failed";
            readonly job: unknown;
        };
    };
    jobCanceled: (job: unknown) => {
        readonly type: "job.update";
        readonly payload: {
            readonly kind: "canceled";
            readonly job: unknown;
        };
    };
    jobRetried: (job: unknown) => {
        readonly type: "job.update";
        readonly payload: {
            readonly kind: "retried";
            readonly job: unknown;
        };
    };
    presenceSync: (peers: unknown[]) => {
        readonly type: "presence.sync";
        readonly payload: {
            readonly peers: unknown[];
        };
    };
    presenceJoin: (peer: unknown) => {
        readonly type: "presence.join";
        readonly payload: {
            readonly peer: unknown;
        };
    };
    presenceLeave: (userId: string) => {
        readonly type: "presence.leave";
        readonly payload: {
            readonly userId: string;
        };
    };
    presenceUpdate: (userId: string, state: Record<string, unknown>) => {
        readonly type: "presence.update";
        readonly payload: {
            readonly userId: string;
            readonly state: Record<string, unknown>;
        };
    };
};
/**
 * Handler map keyed by a message's string `type`. Every key maps to the
 * payload type of the matching arm in `M`, so handlers get automatic
 * payload narrowing with no runtime checks.
 *
 * Narrowing requires each `M` arm to use a string-literal `T`; widening
 * `M` to `BaseMessage<string, unknown>` collapses all keys to a single
 * untyped `string` and the map becomes a plain `Record<string, (p: unknown)
 * => void>`.
 */
type MessageHandlers<M extends BaseMessage<string, unknown> = ProtocolMessage> = {
    [K in M as K['type']]?: (payload: K['payload']) => void;
};
/**
 * Parse and route an incoming wire message. Accepts either the raw JSON
 * string (directly from `ws.onmessage`'s `event.data`) or an already-
 * parsed object. Returns `true` if a handler ran, `false` otherwise
 * (unrecognised type, parse failure, or malformed envelope).
 *
 * Defaults `M` to `ProtocolMessage` so callers who don't care about
 * direction can just do `dispatch(raw, handlers)`; narrow with
 * `dispatch<ClientMessage>` / `dispatch<ServerMessage>` to restrict which
 * arms the handler map is allowed to cover.
 */
declare function dispatch<M extends BaseMessage<string, unknown> = ProtocolMessage>(raw: unknown, handlers: MessageHandlers<M>): boolean;
/**
 * Serialise a typed-built message for `ws.send`. A tiny wrapper around
 * `JSON.stringify` kept around so call sites read as
 * `ws.send(encode(clientBuild.canvasAdd(...)))` rather than paying
 * attention to stringify arguments.
 */
declare function encode<M extends BaseMessage<string, unknown>>(message: M): string;

/**
 * BaseRoom — Abstract base class for all DeepSpace Durable Objects.
 *
 * Provides:
 * - WebSocket upgrade with Cloudflare hibernation API
 * - Connection tracking (WebSocket -> UserAttachment)
 * - Auth: parse JWT-verified user info from internal request headers
 * - Presence: connected users list, awareness on connect/disconnect
 * - Message routing: JSON parse -> dispatch by `type` field, binary hook
 * - Raw SQLite access via this.sql
 * - Broadcast helpers: broadcast(), sendTo()
 * - HTTP fetch handler with WebSocket upgrade detection
 * - Internal control-plane endpoint: POST /internal/disconnect-sockets
 *   (force every client to reconnect and resync after out-of-band writes)
 *
 * Subclasses implement lifecycle hooks:
 *   onConnect, onMessage, onBinaryMessage, onDisconnect, onRequest, onAlarm
 */

interface UserAttachment {
    userId: string;
    userName: string;
    userEmail: string;
    userImageUrl?: string;
    /** Subclass-specific data serialized alongside user info */
    [key: string]: unknown;
}
declare abstract class BaseRoom<E = Record<string, unknown>> {
    protected state: DurableObjectState;
    protected env: E;
    protected sql: SqlStorage;
    constructor(state: DurableObjectState, env: unknown);
    fetch(request: Request): Promise<Response>;
    /**
     * Handle built-in `/internal/*` control-plane routes shared by every room
     * type. Returns a `Response` if the request was an internal route, or `null`
     * to let the caller continue normal dispatch.
     *
     * Currently:
     * - `POST /internal/disconnect-sockets` — close every live WebSocket so
     *   clients reconnect and resync. Optional JSON body `{ code?, reason? }`
     *   overrides the defaults (1012 / 'state-refresh'). Responds with
     *   `{ success: true, closed: <n> }`.
     *
     * See the security note on `fetch()`: this path is only reachable via DO
     * stub fetch from the app worker, never from the public internet.
     */
    protected handleInternalRequest(request: Request, url: URL): Promise<Response | null>;
    private handleWebSocketUpgrade;
    webSocketMessage(ws: WebSocket, message: ArrayBuffer | string): Promise<void>;
    webSocketClose(ws: WebSocket, _code: number, _reason: string): Promise<void>;
    webSocketError(_ws: WebSocket, error: unknown): Promise<void>;
    alarm(): Promise<void>;
    /**
     * Called when a new WebSocket connects (after auth parsing).
     * Return an augmented attachment to serialize on the WebSocket,
     * or void to use the default attachment.
     */
    protected onConnect(_ws: WebSocket, _user: UserAttachment): UserAttachment | void | Promise<UserAttachment | void>;
    /**
     * Called for each parsed JSON message.
     */
    protected abstract onMessage(ws: WebSocket, user: UserAttachment, message: {
        type: string;
        [key: string]: unknown;
    }): void | Promise<void>;
    /**
     * Called for binary messages (Yjs, custom protocols).
     */
    protected onBinaryMessage?(ws: WebSocket, user: UserAttachment, data: ArrayBuffer): void | Promise<void>;
    /**
     * Called when a WebSocket disconnects.
     */
    protected onDisconnect(_ws: WebSocket, _user: UserAttachment): void | Promise<void>;
    /**
     * Called for HTTP requests that are NOT WebSocket upgrades.
     */
    protected onRequest?(request: Request): Response | Promise<Response>;
    /**
     * Called on DO alarm.
     */
    protected onAlarm?(): void | Promise<void>;
    /**
     * Get all connected WebSockets.
     */
    protected getWebSockets(): WebSocket[];
    /**
     * Force every connected client to reconnect and resync by closing all live
     * WebSockets. Returns the number of sockets closed.
     *
     * Use this after an **out-of-band, server-side write** to the room's records
     * — an admin import route, a migration script, a cron job, or a server
     * action — that connected clients have no way to learn about. Without it, a
     * browser tab holding stale in-memory state keeps operating on (and may
     * autosave over) data that changed underneath it. Closing the socket makes
     * the client SDK reconnect and pull fresh query results.
     *
     * The default close code is 1012 ("service restart") with reason
     * 'state-refresh'. The DeepSpace client treats *any* close as a reconnect
     * trigger (it does not special-case clean/1000 closes), so on reconnect it
     * re-subscribes every active query and receives fresh `QUERY_RESULT`s —
     * `useQuery` consumers see the new data without re-subscribing.
     *
     * Each close is guarded so one already-closing socket can't abort the sweep.
     *
     * @param options.code   WebSocket close code (default 1012).
     * @param options.reason WebSocket close reason (default 'state-refresh').
     * @returns the number of sockets that were closed.
     */
    disconnectAllSockets(options?: {
        code?: number;
        reason?: string;
    }): number;
    /**
     * Get the user attachment for a WebSocket.
     */
    protected getAttachment(ws: WebSocket): UserAttachment | null;
    /**
     * Get all currently connected users.
     */
    protected getConnectedUsers(): UserAttachment[];
    /**
     * Send a JSON message to a specific WebSocket.
     *
     * Typed as `ServerMessage` so every room's outbound traffic is
     * compile-checked against the wire protocol contract. Passing
     * `{ type: 'whatever', payload: {...} }` with a non-matching arm fails
     * to compile — that's the whole point of the typed layer. Apps that
     * need to send an app-specific message should override `sendTo` in
     * their subclass with a widened union (`ServerMessage | MyAppMessage`).
     */
    protected sendTo(ws: WebSocket, message: ServerMessage): void;
    /**
     * Send binary data to a specific WebSocket.
     */
    protected sendBinaryTo(ws: WebSocket, data: Uint8Array | ArrayBuffer): void;
    /**
     * Broadcast a JSON message to all connected WebSockets.
     * Optionally exclude a specific WebSocket (e.g. the sender).
     *
     * See `sendTo` for the reasoning behind typing as `ServerMessage`.
     */
    protected broadcast(message: ServerMessage, exclude?: WebSocket): void;
    /**
     * Broadcast binary data to all connected WebSockets.
     */
    protected broadcastBinary(data: Uint8Array | ArrayBuffer, exclude?: WebSocket): void;
}

/**
 * Shared type definitions for the DeepSpace SDK
 *
 * Types used by both client-side SDK and server-side workers.
 */
type ColumnInterpretation = {
    kind: 'plain';
} | {
    kind: 'currency';
    symbol: string;
    decimals: number;
} | {
    kind: 'date';
    format?: string;
} | {
    kind: 'datetime';
    format?: string;
} | {
    kind: 'boolean';
    trueLabel?: string;
    falseLabel?: string;
} | {
    kind: 'percent';
    decimals?: number;
} | {
    kind: 'select';
    options: string[];
} | {
    kind: 'multiselect';
    options: string[];
} | {
    kind: 'url';
} | {
    kind: 'email';
} | {
    kind: 'json';
} | {
    kind: 'reference';
    targetTable: string;
    displayColumn: string;
};
interface ColumnDefinition {
    /** Stable ID override (survives renames). Falls back to `col_{name}`. */
    id?: string;
    name: string;
    storage: 'number' | 'text';
    interpretation: ColumnInterpretation | string;
    expression?: string;
    userBound?: boolean;
    immutable?: boolean;
    required?: boolean;
    default?: unknown;
    timestampTrigger?: {
        field: string;
        value?: unknown;
    };
}
type PermissionLevel = boolean | 'own' | 'unclaimed-or-own' | 'collaborator' | 'team' | 'access' | 'published' | 'shared';
interface RolePermissions {
    read: PermissionLevel;
    /** Create has no existing record to evaluate, so it is an explicit grant. */
    create: boolean;
    update: PermissionLevel;
    delete: PermissionLevel;
    /** If set, only these caller-supplied columns can be created or updated by this role. */
    writableFields?: string[];
}
interface CollectionSchema {
    name: string;
    /** Every collection is stored in typed SQL columns. */
    columns: ColumnDefinition[];
    /** Composite uniqueness constraint (for example `['userId', 'taskId']`). */
    uniqueOn?: string[];
    /** Ownership column; defaults to the row creator. */
    ownerField?: string;
    /** Column containing a JSON array of collaborator user ids. */
    collaboratorsField?: string;
    /** Column containing the team id used by team permission rules. */
    teamField?: string;
    /** A string is public when equal to `public`; an object supplies an exact value. */
    visibilityField?: string | {
        field: string;
        value: unknown;
    };
    /** Permissions per role; `*` is the catch-all role. */
    permissions: Record<string, RolePermissions>;
    /** Default role assigned on the `users` collection. */
    defaultRole?: string;
    /**
     * `users` collection only: what the `user.list` roster shows a non-admin
     * whose `read` policy is row-scoped (`'own'`, `'team'`, …). Default
     * `'public-identity'`: every registered user's id/name/imageUrl/role/lastSeenAt
     * (`lastSeenAt` is what `usePresence` reads) — the
     * row policy keeps guarding full-row reads on the records/query path.
     * `'read-policy'`: the roster contains only the rows the caller's read
     * policy grants (still projected to public identity) — for apps that scope
     * users to a tenant/team and must not show names across it.
     */
    roster?: 'public-identity' | 'read-policy';
}
interface Query {
    collection: string;
    where?: Record<string, unknown>;
    orderBy?: string;
    orderDir?: 'asc' | 'desc';
    limit?: number;
}
interface Subscription {
    id: string;
    query: Query;
}
/** Key for Yjs doc: collection:recordId:fieldName */
type YjsDocKey = string;
interface YjsSubscription {
    collection: string;
    recordId: string;
    fieldName: string;
}
interface RecordResult {
    recordId: string;
    data: Record<string, unknown>;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}

/**
 * Server-specific protocol types
 *
 * These depend on Cloudflare Workers / Yjs imports and can't live in shared/types.
 * All other protocol types (Query, payloads, etc.) live in shared/types/index.ts.
 */

/** Stored on WebSocket attachment (survives hibernation) */
interface ConnectionAttachment extends UserAttachment {
    role: string;
    subscriptions: Subscription[];
    /** Yjs docs this connection is editing */
    yjsSubscriptions: YjsSubscription[];
    /** Client-side Yjs awareness clientId for each subscribed document. */
    awarenessClientIds?: Partial<Record<YjsDocKey, number>>;
}
/**
 * Context passed to handlers for accessing shared resources.
 *
 * `send` is typed against `ServerMessage` so every outbound message is
 * compile-checked against the wire-protocol discriminated union. See
 * `shared/protocol/messages.ts` for why.
 */
interface HandlerContext {
    sql: SqlStorage;
    state: DurableObjectState;
    yjsDocs: Map<YjsDocKey, Y.Doc>;
    getWebSockets(): Iterable<WebSocket>;
    send(ws: WebSocket, message: ServerMessage): void;
    sendBinary(ws: WebSocket, data: Uint8Array): void;
}

/**
 * Collection Schema Definitions & Validation
 *
 * All collections use typed SQL columns. No document-mode / fields-based storage.
 */

interface ResolvedColumn {
    id: string;
    name: string;
    storage: 'number' | 'text';
    interpretation: ColumnInterpretation;
    expression?: string;
    readonly: boolean;
    userBound?: boolean;
    immutable?: boolean;
    required?: boolean;
    default?: unknown;
    timestampTrigger?: {
        field: string;
        value?: unknown;
    };
}
declare function collectionTableName(name: string): string;
declare function columnId(name: string): string;
declare function resolveColumn(col: ColumnDefinition): ResolvedColumn;
declare function rowToData(row: Record<string, unknown>, columns: ResolvedColumn[]): Record<string, unknown>;
declare function dataToColumnValues(data: Record<string, unknown>, columns: ResolvedColumn[]): Record<string, unknown>;
declare function coerceValue(value: unknown, storage: 'number' | 'text', interpretation: ColumnInterpretation): unknown;
/** Canonical numeric representation for date/datetime storage and triggers. */
declare function epochSeconds(date?: Date): number;
declare function buildTableSelect(collectionName: string, columns: ResolvedColumn[]): string;
interface User {
    id: string;
    email: string;
    name: string;
    imageUrl?: string;
    role: string;
    createdAt: string;
    lastSeenAt: string;
}
interface StoredRecord {
    collection: string;
    recordId: string;
    data: Record<string, unknown>;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}
interface PermissionContext {
    isTeamMember: (teamId: string, userId: string) => boolean;
}
declare const noopPermissionContext: PermissionContext;
declare function getRolePermissions(schema: CollectionSchema, role: string): RolePermissions;
declare function isOwner(schema: CollectionSchema, record: {
    data: Record<string, unknown>;
    createdBy: string;
}, userId: string): boolean;
declare function canRead(schema: CollectionSchema, role: string, record: {
    data: Record<string, unknown>;
    createdBy: string;
    recordId?: string;
}, userId: string, ctx?: PermissionContext): boolean;
declare function canCreate(schema: CollectionSchema, role: string): boolean;
declare function canUpdate(schema: CollectionSchema, role: string, record: {
    data: Record<string, unknown>;
    createdBy: string;
    recordId?: string;
}, userId: string, ctx?: PermissionContext): boolean;
declare function canDelete(schema: CollectionSchema, role: string, record: {
    data: Record<string, unknown>;
    createdBy: string;
    recordId?: string;
}, userId: string, ctx?: PermissionContext): boolean;
/** Check if a caller-supplied field write violates writableFields restrictions. */
declare function checkFieldPermissions(schema: CollectionSchema, role: string, newData: Record<string, unknown>, existingData?: Record<string, unknown>): string | null;
/**
 * `unclaimed-or-own` lets a client claim an empty owner field, but never lets
 * them choose another user's id. Check the post-write record so the invariant
 * covers both creation and updates while still allowing an owner to unclaim.
 */
declare function checkUnclaimedOwnerTransition(schema: CollectionSchema, role: string, nextData: Record<string, unknown>, userId: string): string | null;
/**
 * Columns the system *assigns* — from the identity provider at registration,
 * or from an admin action. A caller who sends one of these has chosen a value
 * and means it, so a record write that would change one is refused loudly
 * rather than silently dropped.
 */
declare const SYSTEM_ASSIGNED_COLUMNS: Set<string>;
/**
 * Columns the system *maintains* on its own schedule, without telling anyone.
 * `registerUser` bumps `lastSeenAt` on every WS connect and `handleUserUpdate`
 * rewrites it on every 60s presence heartbeat; neither broadcasts, so every
 * client's copy goes stale silently and there is no heal path short of a
 * refetch. Read-modify-write echo (`put(id, { ...rec.data, field })`) is the
 * SDK's own house style, so refusing these would refuse writes over a value the
 * caller never chose and cannot keep current. They are preserved silently.
 */
declare const SYSTEM_MAINTAINED_COLUMNS: Set<string>;
/** Every `users` column owned by the system rather than by record writes. */
declare const SYSTEM_MANAGED_COLUMNS: Set<string>;
/** Standard user columns. Apps spread these into their users schema. */
declare const USERS_COLUMNS: ColumnDefinition[];
declare const BASE_USERS_SCHEMA: CollectionSchema;
/**
 * Lint a CollectionSchema for declarations that look like they should
 * enforce something but don't, due to interactions between top-level
 * fields (visibilityField, ownerField) and per-role permission levels.
 *
 * The SDK has historically silently accepted schemas that imply more
 * enforcement than they actually deliver — e.g., `visibilityField` set
 * but every role's `read: true` means "anyone can read everything"
 * regardless of `visibility`. Warn loudly at registration so app
 * authors notice before shipping a privacy bug.
 *
 * Returns an array of warning messages. Empty = clean.
 */
declare function lintSchema(schema: CollectionSchema): string[];
/**
 * Lint a whole schema set: every per-schema warning, plus the rules that
 * need to see the set. The `'team'` permission level resolves membership from
 * a `team_members` collection (`teamId`, `userId`, `status`); without one it
 * denies everything, silently — a mistake that presents as a sync bug, not
 * as a schema error, so name it here.
 */
declare function lintSchemas(schemas: CollectionSchema[]): string[];
/** The rules that need to see the whole schema set (per-schema rules live in
 *  `lintSchema`; `lintSchemas` composes both). */
declare function lintSchemaSet(schemas: CollectionSchema[]): string[];
declare class SchemaRegistry {
    private trusted;
    constructor(schemas?: CollectionSchema[]);
    registerTrusted(schema: CollectionSchema): void;
    get(name: string): CollectionSchema | undefined;
    has(name: string): boolean;
    all(): CollectionSchema[];
    names(): string[];
}

/**
 * RecordRoom Durable Object
 *
 * SQLite-based storage with query-based real-time subscriptions.
 * Extends BaseRoom for WebSocket/connection infrastructure.
 *
 * Architecture:
 * - Data stored in SQLite (single `records` table)
 * - Clients subscribe to QUERIES, not collections
 * - On record change, server evaluates which subscriptions match
 * - Only matching subscribers receive updates
 *
 * Protocol:
 * - SUBSCRIBE { subscriptionId, query } → QUERY_RESULT { subscriptionId, records }
 * - UNSUBSCRIBE { subscriptionId }
 * - PUT { collection, recordId, data } → broadcasts RECORD_CHANGE to matching
 * - DELETE { collection, recordId } → broadcasts RECORD_CHANGE to matching
 */

/**
 * RecordRoom configuration options
 */
interface RecordRoomConfig {
    /**
     * User ID of the app owner.
     * This user automatically gets 'admin' role on connect.
     */
    ownerUserId?: string;
}
/**
 * RecordRoom Durable Object
 */
declare class RecordRoom<E = Record<string, unknown>> extends BaseRoom<E> {
    private schemaRegistry;
    private initPromise;
    /** Yjs docs loaded in memory (key: collection:recordId:fieldName) */
    private yjsDocs;
    /** Owner user ID — gets admin role automatically */
    private ownerUserId;
    /** True until the first fetch() completes — detects hibernation wake-up */
    private freshConstruct;
    /**
     * Per-connection `[DO Perf]` timing logs are noisy on every hot path, so
     * they're gated behind a `DEEPSPACE_DO_PERF` env binding (set it to any
     * truthy value on the worker to opt in). Off by default.
     */
    private get perfLogEnabled();
    /**
     * The HTTP debug API (`/api/debug/*`) runs arbitrary SQL and role changes
     * with no auth of its own, so it is gated here at the DO's single ingress.
     * Off unless a deployment opts in with `ALLOW_DEBUG_ROUTES=true`
     * (`deepspace dev start`/`test run` set it automatically). Deployments holding shared
     * data override this to always return false.
     */
    protected get debugRoutesEnabled(): boolean;
    constructor(state: DurableObjectState, env: unknown, schemas?: CollectionSchema[], config?: RecordRoomConfig);
    private getPermissionContext;
    fetch(request: Request): Promise<Response>;
    /** Timing info from the current fetch(), used by onConnect for logging */
    private _fetchTiming;
    private ensureInitialized;
    private initializeDatabase;
    private ensureCollectionTable;
    private ensureAllCollectionTables;
    protected onConnect(ws: WebSocket, user: UserAttachment): Promise<ConnectionAttachment>;
    /**
     * Required to satisfy BaseRoom's abstract contract, but never invoked:
     * RecordRoom overrides `webSocketMessage`/`webSocketClose` directly (below),
     * so the BaseRoom dispatch path that would call this never runs. All real
     * message handling lives in `handleRecordMessage`.
     */
    protected onMessage(): void;
    webSocketMessage(ws: WebSocket, message: ArrayBuffer | string): Promise<void>;
    webSocketClose(ws: WebSocket, code: number, reason: string): Promise<void>;
    private handleRecordMessage;
    private handleListSchemas;
    private createHandlerContext;
    private createRecordContext;
    private createUserContext;
    private createYjsContext;
    private send;
    private sendBinaryHelper;
}

/**
 * YjsRoom — Lightweight Durable Object for collaborative Yjs documents.
 * Extends BaseRoom for WebSocket/connection infrastructure.
 *
 * Unlike RecordRoom (schemas, RBAC, queries, user state), YjsRoom is
 * purpose-built for Yjs: sync, relay, persist. One DO per document.
 *
 * Architecture (SOTA for Yjs + Cloudflare DOs):
 * - Auth verified at the worker edge, role passed to DO via URL params
 * - DO is a thin Yjs sync relay: receive → apply → persist → broadcast
 * - Viewers can observe but not write; members/admins can write
 * - State persisted as a single binary blob in SQLite
 *
 * Uses the shared yjs-protocol.ts encoding utilities — no duplication.
 */

interface YjsAttachment extends UserAttachment {
    role: string;
    canWrite: boolean;
    awarenessClientId: number | null;
}
declare class YjsRoom<E = Record<string, unknown>> extends BaseRoom<E> {
    private doc;
    private initialized;
    private awarenessStates;
    constructor(state: DurableObjectState, env: unknown);
    private ensureInitialized;
    private getDoc;
    private persistDoc;
    protected onConnect(ws: WebSocket, user: UserAttachment): YjsAttachment;
    protected onMessage(_ws: WebSocket, _user: UserAttachment, _message: {
        type: string;
        [key: string]: unknown;
    }): void;
    protected onBinaryMessage(ws: WebSocket, _user: UserAttachment, data: ArrayBuffer): void;
    protected onDisconnect(ws: WebSocket, _user: UserAttachment): void;
    private handleSync;
    private handleAwareness;
    private readAwarenessUpdates;
    private encodeAwarenessMessage;
    private sendAwarenessSnapshot;
    private broadcastRaw;
}

/**
 * CanvasRoom — Spatial canvas Durable Object (tldraw-style).
 *
 * Extends BaseRoom with Yjs-backed spatial operations.
 * Each shape is a Y.Map entry, enabling multi-user concurrent editing.
 *
 * Features:
 * - Shape CRUD (add, move, resize, delete, update properties)
 * - Viewport awareness (each user's visible region)
 * - Per-user undo/redo stacks
 *
 * Message types: canvas.*
 */

interface CanvasShape {
    id: string;
    type: string;
    x: number;
    y: number;
    width: number;
    height: number;
    rotation?: number;
    props: Record<string, unknown>;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}
interface Viewport {
    userId: string;
    x: number;
    y: number;
    width: number;
    height: number;
    zoom: number;
}
interface CanvasAttachment extends UserAttachment {
    viewport: Viewport | null;
    /** True for member/admin roles; false for viewers and unauthenticated anon. */
    canWrite: boolean;
}
declare class CanvasRoom<E = Record<string, unknown>> extends BaseRoom<E> {
    private doc;
    private initialized;
    private viewports;
    private undoStacks;
    private redoStacks;
    constructor(state: DurableObjectState, env: unknown);
    private ensureInitialized;
    private getDoc;
    private persistDoc;
    private getShapesMap;
    fetch(request: Request): Promise<Response>;
    protected onConnect(ws: WebSocket, user: UserAttachment): CanvasAttachment;
    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
        type: string;
        [key: string]: unknown;
    }): Promise<void>;
    protected onDisconnect(_ws: WebSocket, user: UserAttachment): void;
    private pushUndo;
    private clearRedo;
    private handleUndo;
    private handleRedo;
    private getAllShapes;
}

/**
 * PresenceRoom — Ephemeral presence-tracking Durable Object.
 *
 * Extends BaseRoom. No SQLite — purely in-memory presence state.
 * Tracks who is present in a given scope (canvas, doc, thread, etc.)
 * and broadcasts join/leave/state-update events to all connected peers.
 *
 * Each scope ID maps to its own DO instance. Clients connect via
 * /ws/presence/:scopeId and receive real-time presence for that scope.
 *
 * Peers can attach small ephemeral state (cursor position, typing indicator,
 * viewport, selection, etc.) via MSG.PRESENCE_UPDATE.
 *
 * Message types: presence.*
 */

interface PresencePeer {
    userId: string;
    userName: string;
    joinedAt: string;
    /** Small per-user state (cursor, typing, viewport, etc.) */
    state: Record<string, unknown>;
}
interface PresenceAttachment extends UserAttachment {
    joinedAt: string;
}
declare class PresenceRoom<E = Record<string, unknown>> extends BaseRoom<E> {
    private peers;
    private peerSockets;
    constructor(state: DurableObjectState, env: unknown);
    /**
     * Durable Objects can hibernate and clear heap while Cloudflare keeps
     * WebSocket connections. Deserialize attachments from already-connected
     * sockets so `peers` matches reality before we send PRESENCE_SYNC.
     */
    private hydratePeersFromLiveSockets;
    protected onConnect(ws: WebSocket, user: UserAttachment): PresenceAttachment;
    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
        type: string;
        [key: string]: unknown;
    }): Promise<void>;
    protected onDisconnect(ws: WebSocket, user: UserAttachment): void;
}

/** Pure validation and evaluation for CronRoom schedules. */
interface CronTask {
    name: string;
    /** Interval in minutes (interval mode) — mutually exclusive with `schedule`. */
    intervalMinutes?: number;
    /** 5-field cron expression (cron mode) — requires `timezone`. */
    schedule?: string;
    /** IANA timezone string (e.g. "America/New_York"). Required with `schedule`. */
    timezone?: string;
    /** Whether the task starts paused. */
    paused?: boolean;
}

/**
 * CronRoom — Per-app scheduled task execution Durable Object.
 *
 * Extends BaseRoom. One DO per app shards cron work and avoids the
 * dispatch-worker's global KV-poll bottleneck. The DO alarm triggers
 * `onTask(name)` on the configured cadence; each execution is recorded
 * to a per-app `cron_history` table. Subscribers (admin clients via the
 * `useCronMonitor` hook) get pushes over the WebSocket.
 *
 * Tasks declare *either* `intervalMinutes` (run every N minutes) *or*
 * `schedule` + `timezone` (5-field cron expression evaluated against an
 * IANA timezone via `Intl.DateTimeFormat`). Cron mode is DST-aware
 * because the wall-clock comparison happens after the timezone shift,
 * not before.
 *
 * Message types: cron.*
 */

interface CronRoomConfig {
    tasks: CronTask[];
}
interface CronExecution {
    taskName: string;
    startedAt: string;
    completedAt: string | null;
    success: boolean;
    durationMs: number;
    error?: string;
}
interface CronAttachment extends UserAttachment {
    /** True for member/admin roles; false for viewers and unauthenticated anon. */
    canWrite: boolean;
}
declare abstract class CronRoom<E = Record<string, unknown>> extends BaseRoom<E> {
    private tasks;
    private initialized;
    constructor(state: DurableObjectState, env: unknown, config: CronRoomConfig);
    private ensureInitialized;
    fetch(request: Request): Promise<Response>;
    protected handleInternalRequest(request: Request, url: URL): Promise<Response | null>;
    protected onConnect(ws: WebSocket, user: UserAttachment): CronAttachment;
    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
        type: string;
        [key: string]: unknown;
    }): Promise<void>;
    private dispatchMessage;
    protected onAlarm(): Promise<void>;
    private executeTask;
    private scheduleNextAlarm;
    private getTaskStates;
    private getRecentHistory;
    private broadcastStatus;
    /**
     * Receipt for a mutation frame, addressed only to its sender. Receipts
     * are opt-in by correlation id: frames without a `requestId` keep the
     * fire-and-forget contract, so the (untyped) `requestId` from the wire
     * is the single gate here rather than a check at every call site.
     * Frames go through the shared `serverBuild` constructors so the wire
     * shape is enforced by the protocol types, not re-spelled here.
     */
    private ackMutation;
    /**
     * Execute a scheduled task by name.
     * Called both by the alarm scheduler and manual trigger.
     */
    protected abstract onTask(taskName: string): void | Promise<void>;
}
/**
 * Wake the app's CronRoom so its alarm is armed.
 *
 * A Durable Object does not exist until something fetches it, and CronRoom
 * arms its alarm inside that first fetch — so a deployed schedule that no
 * client has opened yet runs nothing, and nothing reports it. The app worker
 * calls this from its request path (once per isolate is enough); the first
 * request the worker handles after a deploy then arms the schedule. A no-op
 * when the app declares no tasks. The wake runs under `ctx.waitUntil`, so it
 * never delays the response.
 */
declare function armCronRoom(ctx: {
    waitUntil(promise: Promise<unknown>): void;
}, namespace: DurableObjectNamespace, roomId: string, tasks: readonly CronTask[]): void;

/**
 * JobRoom — Per-app durable background-job execution Durable Object.
 *
 * Solves the "long job dies when the response goes out" problem on
 * Cloudflare Workers. `ctx.waitUntil` only gets 30s after a response;
 * jobs that need minutes-to-hours live here instead: rows in SQLite,
 * picked up by DO alarms (15-min wall budget per tick), resumable
 * across ticks via `ctx.continue` for the rare longer cases.
 *
 * Lifecycle: queued → running → succeeded | failed | canceled
 *
 * Crash recovery: if an isolate is recycled mid-run, the row stays at
 * `running`. On next init, rows older than ~16 min are either retried
 * (if attempts left) or marked failed.
 *
 * See the abstract `onJob` method below for the subclass contract.
 * Message types: job.*
 */

type JobStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'canceled';
/**
 * Job record exposed to `onJob` handlers and clients. Payloads are typed
 * as `unknown` at the SDK layer; subclasses narrow via a generic param.
 */
interface Job<P = unknown> {
    id: string;
    type: string;
    status: JobStatus;
    payload: P;
    result?: unknown;
    error?: string;
    progress?: number;
    progressMessage?: string;
    attempts: number;
    maxAttempts: number;
    enqueuedAt: string;
    startedAt?: string | null;
    completedAt?: string | null;
    enqueuedBy?: string | null;
    /** Set when a previous run called `ctx.continue(state)`. */
    resumeFrom?: unknown;
}
interface JobContext {
    /** Set progress (0..1) with an optional message. Broadcasts. */
    progress(value: number, message?: string): void;
    /**
     * Save a resumable checkpoint and re-run `onJob` on the next alarm
     * with `job.resumeFrom = state`. The return value of `onJob` is
     * ignored once `continue` has been called.
     */
    continue(state: unknown, options?: {
        afterMs?: number;
    }): void;
    /**
     * Fires when a JOB_CANCEL arrives while this job is running in this
     * isolate. Cross-isolate cancels still mark the row `canceled` but
     * can't fire this signal.
     */
    signal: AbortSignal;
}
interface JobRoomConfig {
    /** Default for jobs enqueued without explicit `maxAttempts`. Default 1 (no auto-retry). */
    defaultMaxAttempts?: number;
    /** TTL for terminal rows (succeeded/failed/canceled) in ms. Default 24h. */
    retentionMs?: number;
    /** Job count in the initial snapshot to a new subscriber. Default 100. */
    snapshotLimit?: number;
    /** Delay before a failed attempt is retried, in ms. Default 1000. */
    retryBackoffMs?: number;
    /** Re-check whether a connected user may mutate the queue. Defaults to member/admin roles. */
    authorizeWrite?: (user: UserAttachment) => boolean | Promise<boolean>;
    /** Re-check whether a connected user may observe the queue. Defaults to authorizeWrite. */
    authorizeRead?: (user: UserAttachment) => boolean | Promise<boolean>;
}
interface JobAttachment extends UserAttachment {
    canWrite: boolean;
}
declare abstract class JobRoom<E = Record<string, unknown>, P = unknown, R = unknown> extends BaseRoom<E> {
    private initialized;
    private readonly defaultMaxAttempts;
    private readonly retentionMs;
    private readonly snapshotLimit;
    private readonly retryBackoffMs;
    private readonly authorizeWrite;
    private readonly authorizeRead;
    private broadcastQueue;
    /** In-flight jobs in this isolate; lets same-isolate JOB_CANCEL fire the signal. */
    private readonly inFlight;
    /** Set by `ctx.continue` inside `executeJob`; reset before every run. */
    private continueState;
    constructor(state: DurableObjectState, env: unknown, config?: JobRoomConfig);
    private ensureInitialized;
    fetch(request: Request): Promise<Response>;
    protected onConnect(ws: WebSocket, user: UserAttachment): Promise<JobAttachment>;
    protected onMessage(ws: WebSocket, user: UserAttachment, message: {
        type: string;
        [key: string]: unknown;
    }): Promise<void>;
    protected onAlarm(): Promise<void>;
    /**
     * One internal endpoint, `POST /enqueue`, used by the `enqueueJob`
     * helper at the bottom of this file. The room is not meant to be
     * reachable from the public internet; callers route through the app
     * worker (or call `this.enqueue(...)` directly from a subclass).
     *
     * Subclasses overriding `onRequest` should call `super.onRequest(req)`
     * for paths they don't handle.
     */
    protected onRequest(request: Request): Promise<Response>;
    /**
     * Synchronously persist a new job and arm the alarm. Returns the new
     * job. This is the in-isolate path — useful for a subclass `onJob`
     * that wants to chain follow-up work without paying a fetch hop:
     *
     *   protected async onJob(job: Job, ctx: JobContext) {
     *     // ... do work ...
     *     if (needsFollowup) this.enqueue('followup', { parent: job.id })
     *   }
     *
     * Workers code that lives outside the DO isolate (HTTP routes, cron
     * tasks, server actions) cannot call this directly — they must go
     * through the `enqueueJob` helper at the bottom of this file, which
     * routes via the DO's `/enqueue` HTTP endpoint.
     */
    enqueue(type: string, payload?: unknown, options?: {
        maxAttempts?: number;
        enqueuedBy?: string;
    }): Job;
    private insertJob;
    private cancelJob;
    private retryJob;
    /**
     * Drain due jobs in FIFO order. All due jobs share the alarm's
     * 15-min wall budget (a CF property, not a per-job allocation).
     */
    private drainDueJobs;
    private executeJob;
    private makeContext;
    private readStatus;
    /** Reauthorize every live event so role revocation does not leave a stale reader. */
    protected broadcast(message: ServerMessage, exclude?: WebSocket): void;
    private resolveAccess;
    private scheduleNextAlarm;
    private recoverStuckRunning;
    private pruneExpired;
    private getRecentJobs;
    private getJobById;
    /**
     * Run a single job. Return a value for success; throw for failure
     * (retried until attempts >= maxAttempts). Use `ctx.progress` for
     * progress, `ctx.continue(state)` to span multiple alarms, and
     * `ctx.signal` to honor client cancellations.
     */
    protected abstract onJob(job: Job<P>, ctx: JobContext): Promise<R | void> | R | void;
}
/**
 * Enqueue a job from worker code that has the DO namespace. Routed by
 * `roomId` (typically `app:<APP_NAME>`; pass different ids for sharded
 * queues). Returns the new jobId; throws on failure.
 *
 *   const jobId = await enqueueJob(
 *     env.JOB_ROOMS,
 *     `app:${env.APP_NAME}`,
 *     'ai-summarize',
 *     { text },
 *     { maxAttempts: 3 },
 *   )
 */
declare function enqueueJob(namespace: DurableObjectNamespace, roomId: string, type: string, payload?: unknown, options?: {
    maxAttempts?: number;
    enqueuedBy?: string;
}): Promise<string>;

/**
 * DO Manifest — Dynamic Durable Object binding declarations.
 *
 * Apps export a `__DO_MANIFEST__` array in their worker.ts.
 * The CLI extracts it and sends it to the deploy worker,
 * which uses it to generate dynamic CF API bindings and migrations.
 */
interface DOManifestEntry {
    /** CF binding name, e.g. 'RECORD_ROOMS' */
    binding: string;
    /** Exported class name, e.g. 'AppRecordRoom' */
    className: string;
    /** Whether this DO uses SQLite storage */
    sqlite: boolean;
}
type DOManifest = DOManifestEntry[];
/**
 * Utility type: auto-generates Env bindings from a manifest.
 *
 * @example
 * const manifest = [
 *   { binding: 'RECORD_ROOMS', className: 'AppRecordRoom', sqlite: true },
 * ] as const satisfies DOManifest
 *
 * type Env = BaseEnv & DOBindings<typeof manifest>
 * // => { RECORD_ROOMS: DurableObjectNamespace }
 */
type DOBindings<T extends readonly DOManifestEntry[]> = {
    [K in T[number]['binding']]: DurableObjectNamespace;
};
/** Default manifest for apps that don't declare one */
declare const DEFAULT_DO_MANIFEST: DOManifest;
/**
 * Shape-validate a DO manifest received over the wire (e.g. from the CLI's
 * deploy form-field). Without this, malformed input gets passed straight to
 * `deployToWfP`'s `.filter(...).map(...)` chain and crashes the route mid-deploy.
 *
 * Mirrors the contract of `validateBindingManifest` for non-DO bindings.
 */
declare function validateDoManifest(manifest: unknown): {
    valid: true;
    manifest: DOManifest;
} | {
    valid: false;
    reason: string;
};

/**
 * Binding Manifest — non-DO bindings declared by an app's wrangler.toml that
 * the deploy-worker should pass through to Cloudflare's WfP upload API.
 *
 * Apps don't export a `__BINDING_MANIFEST__`; the CLI extracts these from the
 * normalized vite/wrangler output config at deploy time. This file just owns
 * the types + validation so both sides (CLI client and deploy-worker server)
 * agree on the shape.
 */
/**
 * A single non-DO binding the app declares. Mirrors CF's WfP binding API.
 *
 * Provisionable resources (d1, kv_namespace, vectorize, r2_bucket, queue) accept
 * the literal string `"auto"` in their ID field to request platform-side
 * provisioning at deploy time. When `"auto"` is used, the deploy-worker creates
 * the resource on the platform CF account, persists the resulting CF ID in the
 * app registry, and substitutes the real ID before forwarding to WfP. The
 * sentinel sticks around in this type because:
 *   1. `wrangler` parsing requires a non-empty string in the id field
 *   2. The CLI passes the unresolved manifest through to the deploy-worker
 *   3. The deploy-worker is the only side with CF API credentials
 *
 * Companion fields (`database_name`, `title`, `dimensions`, `metric`) are only
 * used when `"auto"` is set — they tell the provisioner how to create the
 * resource. After provisioning these fields are still present on the wire but
 * ignored by WfP.
 */
type CustomBinding = {
    type: 'plain_text';
    name: string;
    text: string;
} | {
    type: 'json';
    name: string;
    json: BindingJsonValue;
} | {
    /** Managed by DeepSpace; never forwarded into the customer Worker env. */
    type: 'ai_search';
    name: string;
    /** Only the untrusted `auto` sentinel is accepted from wrangler.toml. */
    instance_name: string;
} | {
    type: 'vectorize';
    name: string;
    /** Either a pre-existing index name or the literal `"auto"`. */
    index_name: string;
    /** Required when `index_name === "auto"`. */
    dimensions?: number;
    /** Required when `index_name === "auto"`. */
    metric?: 'cosine' | 'euclidean' | 'dot-product';
} | {
    type: 'ai';
    name: string;
} | {
    type: 'r2_bucket';
    name: string;
    /** Either a pre-existing bucket name or the literal `"auto"`. */
    bucket_name: string;
} | {
    type: 'kv_namespace';
    name: string;
    /** Either a pre-existing KV namespace ID or the literal `"auto"`. */
    namespace_id: string;
    /** Required when `namespace_id === "auto"`. Human-readable namespace title. */
    title?: string;
} | {
    type: 'd1';
    name: string;
    /** Either a pre-existing D1 database UUID or the literal `"auto"`. */
    id: string;
    /** Required when `id === "auto"`. Human-readable database name. */
    database_name?: string;
} | {
    type: 'queue';
    name: string;
    /** Either a pre-existing queue name or the literal `"auto"`. */
    queue_name: string;
} | {
    type: 'browser_rendering';
    name: string;
} | {
    type: 'analytics_engine';
    name: string;
    dataset?: string;
} | {
    type: 'hyperdrive';
    name: string;
    id: string;
} | {
    type: 'ratelimit';
    name: string;
    namespace_id: string;
    simple: {
        limit: number;
        period: 10 | 60;
    };
};
type CustomBindingManifest = CustomBinding[];
/** Values Wrangler accepts for JSON environment-variable bindings. */
type BindingJsonValue = null | boolean | number | string | BindingJsonValue[] | {
    [key: string]: BindingJsonValue;
};
/** Cloudflare's maximum UTF-8 payload for one environment variable. */
declare const MAX_ENV_VAR_BYTES: number;
/**
 * Bound on names that become Cloudflare binding names verbatim (declared
 * bindings and app secrets). Cloudflare itself caps a binding name at 2712
 * bytes but only rejects at deploy time — after a too-long secret name was
 * already accepted into the store, which bricks every later deploy. Refuse at
 * write time instead, with a bound no sane name exceeds.
 */
declare const MAX_BINDING_NAME_LENGTH = 256;
/** One rule for user secret names, shared by the CLI's fail-fast validation
 * and the deploy-worker's authoritative store so the layers cannot drift. */
declare const SECRET_NAME_RE: RegExp;
/** Sentinel string in an ID field that requests platform-side provisioning. */
declare const AUTO_PROVISION_SENTINEL = "auto";
/** Binding types whose ID field accepts the `"auto"` sentinel for provisioning. */
declare const AUTO_PROVISIONABLE_TYPES: Set<string>;
/**
 * True if a binding has the `"auto"` sentinel in its primary ID field. Used by
 * the deploy-worker to decide which entries need provisioning and by the
 * validator to enforce companion-field requirements.
 */
declare function isAutoProvision(b: CustomBinding): boolean;
/** Binding `type` values an app is allowed to declare. */
declare const ALLOWED_BINDING_TYPES: Set<string>;
/**
 * Binding NAMES the SDK reserves on every app — apps may not redeclare them.
 *
 * Includes:
 *   - Static-asset + service bindings the platform sets up automatically.
 *   - SDK-managed env (auth, identity, owner JWT).
 *   - The auto-attached cost-tracking AE dataset (`USAGE_EVENTS`).
 *
 * DO binding names (RECORD_ROOMS, YJS_ROOMS, etc.) are NOT in this set
 * because they live in a separate manifest (`__DO_MANIFEST__`).
 */
declare const RESERVED_BINDING_NAMES: Set<string>;
/**
 * Per-binding validation error. `binding` is undefined for top-level
 * shape failures (e.g. manifest is not an array).
 */
interface ValidationError {
    binding?: CustomBinding;
    reason: string;
}
/**
 * Validate a binding manifest. Returns errors; an empty array means valid.
 *
 * Used both client-side (CLI) for friendly fail-fast and server-side
 * (deploy-worker) as a security boundary — apps can't sneak in reserved
 * binding names by editing the wire format.
 */
declare function validateBindingManifest(manifest: unknown): {
    valid: true;
    bindings: CustomBindingManifest;
} | {
    valid: false;
    errors: ValidationError[];
};
/**
 * Convert vite/wrangler's normalized config (from `.wrangler/deploy/config.json`)
 * into a CustomBindingManifest.
 *
 * Vite normalizes wrangler.toml into object/array structures with shapes like
 * `{ ai: { binding: 'AI' } }`, `{ vectorize: [{ binding, index_name }] }`,
 * etc. We extract each known shape with explicit field plucks (no broad
 * `as` casts) and return a flat array.
 */
declare function bindingManifestFromOutputConfig(outputConfig: Record<string, unknown>): CustomBindingManifest;

/**
 * Pure helpers for computing Cloudflare Durable Object migrations from a
 * declared manifest + the bindings already registered on a deployed script.
 *
 * Lives in the SDK (not deploy-worker) so the logic is testable with vitest
 * and reusable from other CF deploy paths if we ever add them.
 */

/** Subset of CF's `bindings` API response we read from. */
interface ExistingDOBinding {
    /** Binding name in `env`, e.g. 'RECORD_ROOMS' */
    name: string;
    /** Always `'durable_object_namespace'` for DO bindings. */
    type: string;
    /** SDK class name, e.g. 'AppRecordRoom' */
    class_name?: string;
}
/** What goes in the CF script-upload `migrations` block. */
interface DoMigrationDirective {
    tag: string;
    new_sqlite_classes?: string[];
    deleted_classes?: string[];
}
interface DoMigrationPlan {
    /** New SQLite classes to register (present in manifest, absent in existing). */
    newSqliteClasses: string[];
    /** Classes to delete (present in existing, absent in manifest). */
    deletedClasses: string[];
    /** True when there's actual delta — only then should the migrations block be sent. */
    needsMigration: boolean;
    /** The full directive to splat into the CF script-upload metadata. Null if no migration is needed. */
    directive: DoMigrationDirective | null;
}
interface ComputeDoMigrationOptions {
    /**
     * Override for the timestamp baked into the migration tag. Tests pass a
     * fixed value to assert determinism; production omits this and gets
     * `Date.now()`, which guarantees lifetime tag uniqueness even across
     * cycles like `[A]→[A,B]→[A]→[A,B]`.
     */
    now?: number;
}
/**
 * Compute the migration plan for a deploy.
 *
 *   manifest:   what the app declares now
 *   existing:   what CF currently has registered for this script
 *
 * Behavior:
 *   - new_sqlite_classes  ← in manifest, not in existing, sqlite=true
 *   - deleted_classes     ← in existing, not in manifest
 *   - needsMigration       ← either of the above is non-empty
 *   - tag                 ← content-addressed by (add, remove) so:
 *                            - identical re-deploy → unchanged tag → no-op (and
 *                              `needsMigration` is false anyway)
 *                            - any class change → unique tag → CF processes
 *
 * Bug history: an earlier version computed `tag = v${count}`. Removing a class
 * dropped the count, the migration block was skipped (no NEW classes), and CF
 * retained the orphaned class registration with its SQLite storage. The
 * `deleted_classes` path closes that gap; the content-addressed tag prevents
 * tag collisions when class sets are added and removed in different orders.
 */
declare function computeDoMigration(manifest: readonly DOManifestEntry[], existing: readonly ExistingDOBinding[], options?: ComputeDoMigrationOptions): DoMigrationPlan;

/**
 * App-name validation + sanitization helpers.
 *
 * Strategy: validate strictly so we have a precise definition of "valid",
 * but DON'T reject non-conforming names — sanitize them, warn the user, and
 * proceed. Hard rejection would break apps whose `wrangler.toml name` was
 * something like `My_App` (previously deployed as `my-app` via silent
 * server-side sanitization). The new behavior preserves "still deploys,"
 * but the CLI now surfaces a warning so the user can fix the name when
 * convenient instead of being silently surprised by their hostname.
 *
 * Rules track Cloudflare's WfP script-name constraints (RFC 1035 host label,
 * no consecutive dashes) plus our 2-char minimum so subdomains read sensibly.
 */
declare const APP_NAME_RULES: {
    /** ^[a-z0-9](-?[a-z0-9])+$ — RFC 1035 host label, no consecutive dashes. */
    readonly pattern: RegExp;
    readonly minLength: 2;
    readonly maxLength: 63;
};
type AppNameValidation = {
    valid: true;
    name: string;
} | {
    valid: false;
    reason: string;
};
/**
 * Strict validation: returns valid only if the name already conforms.
 * Useful as a precondition test or for CI lints.
 */
declare function validateAppName(raw: unknown): AppNameValidation;
type AppNameResolution = {
    ok: true;
    name: string;
    warning?: string;
} | {
    ok: false;
    reason: string;
};
/**
 * Resolve an app name for deploy: prefer the input as-is if valid, otherwise
 * sanitize and warn. Hard-fail only if even sanitization can't produce a
 * valid name (empty, all-non-alphanumeric, too short, too long).
 *
 * The intent is "what previously worked still works, with a friendly warning
 * about non-conforming names."
 */
declare function resolveAppName(raw: unknown): AppNameResolution;

/**
 * AI Chat Schemas
 *
 * Pre-built collection schemas for DO-backed AI chat history.
 * The worker is the only writer; the client reads via `useQuery`.
 */

declare const AI_CHATS_SCHEMA: CollectionSchema;
declare const AI_MESSAGES_SCHEMA: CollectionSchema;

/**
 * Messaging Schemas
 *
 * Pre-built collection schemas for messaging functionality.
 * These schemas intentionally model public channels only. RecordRoom row
 * permissions cannot make a channel private by themselves; advertising DMs
 * or private groups here would expose their records to every room member.
 *
 * @example
 * ```typescript
 * import { CHANNELS_SCHEMA, MESSAGES_SCHEMA, REACTIONS_SCHEMA } from 'deepspace/worker'
 * export const schemas = [usersSchema, CHANNELS_SCHEMA, MESSAGES_SCHEMA, REACTIONS_SCHEMA]
 * ```
 */

declare const CHANNELS_SCHEMA: CollectionSchema;
declare const MESSAGES_SCHEMA: CollectionSchema;
declare const REACTIONS_SCHEMA: CollectionSchema;
declare const CHANNEL_MEMBERS_SCHEMA: CollectionSchema;
declare const READ_RECEIPTS_SCHEMA: CollectionSchema;

/**
 * Yjs Sync Protocol Implementation
 *
 * This implements the y-protocols sync and awareness protocols without
 * depending on y-websocket internal paths. Makes it easier to bundle
 * and template.
 *
 * Protocol spec: https://github.com/yjs/y-protocols
 */

declare const MSG_SYNC = 0;
declare const MSG_AWARENESS = 1;
declare const MSG_SYNC_STEP1 = 0;
declare const MSG_SYNC_STEP2 = 1;
declare const MSG_SYNC_UPDATE = 2;
declare function createEncoder(): {
    data: number[];
};
declare function toUint8Array(encoder: {
    data: number[];
}): Uint8Array;
declare function writeVarUint(encoder: {
    data: number[];
}, num: number): void;
declare function writeVarUint8Array(encoder: {
    data: number[];
}, arr: Uint8Array): void;
declare function createDecoder(data: Uint8Array): {
    data: Uint8Array;
    pos: number;
};
declare function readVarUint(decoder: {
    data: Uint8Array;
    pos: number;
}): number;
declare function readVarUint8Array(decoder: {
    data: Uint8Array;
    pos: number;
}): Uint8Array;
declare function hasContent(decoder: {
    data: Uint8Array;
    pos: number;
}): boolean;
/**
 * Encode sync step 1: our state vector
 */
declare function encodeSyncStep1(doc: Y.Doc): Uint8Array;
/**
 * Encode sync step 2: diff based on received state vector
 */
declare function encodeSyncStep2(doc: Y.Doc, stateVector: Uint8Array): Uint8Array;
/**
 * Encode an incremental update
 */
declare function encodeUpdate(update: Uint8Array): Uint8Array;
interface SyncResult {
    type: 'step1' | 'step2' | 'update';
    response?: Uint8Array;
    stateVector?: Uint8Array;
    update?: Uint8Array;
}
/**
 * Handle an incoming sync message
 * Returns response to send (if any) and whether this was an update
 */
declare function handleSyncMessage(doc: Y.Doc, data: Uint8Array): SyncResult;
interface AwarenessState {
    [key: string]: unknown;
}
interface AwarenessStates {
    [clientId: number]: AwarenessState;
}
/**
 * Simple awareness implementation for presence/cursors
 */
declare class Awareness {
    doc: Y.Doc;
    clientID: number;
    states: Map<number, AwarenessState>;
    private meta;
    private updateListeners;
    private changeListeners;
    constructor(doc: Y.Doc);
    getStates(): Map<number, AwarenessState>;
    getLocalState(): AwarenessState | null;
    setLocalState(state: AwarenessState | null): void;
    setLocalStateField(field: string, value: unknown): void;
    on(event: 'update' | 'change', handler: (changes: {
        added: number[];
        updated: number[];
        removed: number[];
    }) => void): void;
    off(event: 'update' | 'change', handler: (changes: {
        added: number[];
        updated: number[];
        removed: number[];
    }) => void): void;
    private emit;
    /**
     * Encode awareness update for specific clients
     */
    encodeUpdate(clientIds?: number[]): Uint8Array;
    /**
     * Apply awareness update from another client
     */
    applyUpdate(data: Uint8Array): {
        added: number[];
        updated: number[];
        removed: number[];
    };
    /**
     * Remove awareness states for disconnected clients
     */
    removeStates(clientIds: number[]): void;
    /** Release all state and listeners owned by this awareness instance. */
    destroy(): void;
}
/**
 * Encode a full awareness message
 */
declare function encodeAwarenessMessage(awareness: Awareness, clientIds?: number[]): Uint8Array;
/**
 * Decode and apply awareness message
 */
declare function handleAwarenessMessage(awareness: Awareness, data: Uint8Array): {
    added: number[];
    updated: number[];
    removed: number[];
};
/**
 * Get message type from raw data
 */
declare function getMessageType(data: Uint8Array): number;

/** Asset-layer misses became real 404s, and the worker owns the fallback. The
 *  config and the worker's fallback path have to move together. */
declare const WORKER_OWNED_NOT_FOUND_MIGRATION_ID = "2026-08-worker-owned-not-found";
/** Room identity moved to internal headers and privileged room routes gained app-role checks. */
declare const SECURE_ROOM_BOUNDARIES_MIGRATION_ID = "2026-08-secure-room-boundaries";
/** `ActionTools` gained `deleteWhere`, so the app's own tools factory — which
 *  declares that interface as its return type — has to supply it. */
declare const ACTION_TOOLS_DELETE_WHERE_MIGRATION_ID = "2026-08-action-tools-delete-where";
/** The browser's app id moved off a scaffold-time literal onto a build-time
 *  define that `deepspace/build` reads from the wrangler config being built. */
declare const BUILD_INJECTED_APP_ID_MIGRATION_ID = "2026-08-build-injected-app-id";
/** The action route refuses a call without a bearer token as 401 (a cookie
 *  session has none) instead of crashing on a non-null assertion, and the
 *  file states the trust model actions run under. */
declare const ACTION_ROUTES_BEARER_GUARD_MIGRATION_ID = "2026-08-action-routes-bearer-guard";
/** The files proxy identifies a header-less same-origin read (an `<img>`,
 *  `<audio>`, or `<video>` load) by the app-origin session cookie, so private
 *  file URLs render for the signed-in user without tokens or signed URLs. */
declare const FILES_SESSION_COOKIE_READS_MIGRATION_ID = "2026-09-files-session-cookie-reads";
type AppMigrationIdsValidation = {
    valid: true;
    ids: string[];
} | {
    valid: false;
    reason: string;
};
/** Validate the small, provider-neutral migration manifest shipped with an app bundle. */
declare function validateAppMigrationIds(value: unknown): AppMigrationIdsValidation;

/**
 * Canonical DeepSpace model catalog and agent policy.
 *
 * Provider catalogs are discovery inputs, not a safe runtime allowlist: a
 * model is promoted here only after its tool loop, transport, pricing, and
 * streaming contract have been verified end to end through the DeepSpace
 * proxy. Every client picker and server agent profile consumes this module.
 */
type DeepSpaceAIProvider = 'anthropic' | 'openai' | 'cerebras';
type DeepSpaceAgentProfileId = 'application' | 'documentation';
type DeepSpaceAgentSupport = 'multi-step' | 'single-step' | 'none';
interface DeepSpaceAIModel {
    id: string;
    label: string;
    provider: DeepSpaceAIProvider;
    providerLabel: string;
    family: string;
    /** Whether the model is eligible for DeepSpace's server-owned agent loop. */
    agentSupport: DeepSpaceAgentSupport;
    /** Profiles in which the model has passed the complete runtime contract. */
    agentProfiles: readonly DeepSpaceAgentProfileId[];
    /** Provider transport currently used by the DeepSpace proxy adapter. */
    transport: 'messages' | 'chat-completions';
    recommendation: 'frontier' | 'balanced' | 'fast' | 'available' | 'limited';
    note?: string;
}
interface DeepSpaceAgentProfile {
    id: DeepSpaceAgentProfileId;
    defaultModel: string;
    maxSteps: number;
    maxToolCalls?: number;
    allowedTools: 'application-defined' | readonly string[];
}
/**
 * Versioned provenance for the provider catalogs used during the latest
 * promotion review. Keeping this in the shipped artifact makes selection
 * policy auditable without allowing a mutable upstream list to change a
 * deployed app underneath a commit.
 */
declare const DEEPSPACE_MODEL_CATALOG_PROVENANCE: {
    readonly version: "2026-08-04";
    readonly verifiedAt: "2026-08-04";
    readonly sources: {
        readonly anthropic: "https://platform.claude.com/docs/en/api/beta/models/list";
        readonly openai: "https://developers.openai.com/api/docs/models/all";
        readonly cerebras: "https://inference-docs.cerebras.ai/models/overview";
    };
};
declare const DEEPSPACE_AI_MODELS: readonly [{
    readonly id: "claude-fable-5";
    readonly label: "Claude Fable 5";
    readonly family: "Claude 5";
    readonly recommendation: "frontier";
} & {
    readonly provider: "anthropic";
    readonly providerLabel: "Anthropic";
    readonly transport: "messages";
} & {
    agentSupport: "multi-step";
    agentProfiles: readonly ["application", "documentation"];
}, {
    readonly id: "claude-opus-5";
    readonly label: "Claude Opus 5";
    readonly family: "Claude 5";
    readonly recommendation: "frontier";
} & {
    readonly provider: "anthropic";
    readonly providerLabel: "Anthropic";
    readonly transport: "messages";
} & {
    agentSupport: "multi-step";
    agentProfiles: readonly ["application", "documentation"];
}, {
    readonly id: "claude-sonnet-5";
    readonly label: "Claude Sonnet 5";
    readonly family: "Claude 5";
    readonly recommendation: "balanced";
} & {
    readonly provider: "anthropic";
    readonly providerLabel: "Anthropic";
    readonly transport: "messages";
} & {
    agentSupport: "multi-step";
    agentProfiles: readonly ["application", "documentation"];
}, {
    readonly id: "claude-haiku-4-5";
    readonly label: "Claude Haiku 4.5";
    readonly family: "Claude 4.5";
    readonly recommendation: "fast";
} & {
    readonly provider: "anthropic";
    readonly providerLabel: "Anthropic";
    readonly transport: "messages";
} & {
    agentSupport: "multi-step";
    agentProfiles: readonly ["application", "documentation"];
}, {
    readonly id: "gpt-5.6-sol";
    readonly label: "GPT-5.6 Sol";
    readonly family: "GPT-5.6";
    readonly recommendation: "frontier";
} & {
    readonly provider: "openai";
    readonly providerLabel: "OpenAI";
    readonly transport: "chat-completions";
} & {
    agentSupport: "multi-step";
    agentProfiles: readonly ["application", "documentation"];
}, {
    readonly id: "gpt-5.6-terra";
    readonly label: "GPT-5.6 Terra";
    readonly family: "GPT-5.6";
    readonly recommendation: "balanced";
} & {
    readonly provider: "openai";
    readonly providerLabel: "OpenAI";
    readonly transport: "chat-completions";
} & {
    agentSupport: "multi-step";
    agentProfiles: readonly ["application", "documentation"];
}, {
    readonly id: "gpt-5.6-luna";
    readonly label: "GPT-5.6 Luna";
    readonly family: "GPT-5.6";
    readonly recommendation: "fast";
} & {
    readonly provider: "openai";
    readonly providerLabel: "OpenAI";
    readonly transport: "chat-completions";
} & {
    agentSupport: "multi-step";
    agentProfiles: readonly ["application", "documentation"];
}, {
    readonly id: "gpt-oss-120b";
    readonly label: "GPT-OSS 120B";
    readonly provider: "cerebras";
    readonly providerLabel: "Cerebras";
    readonly family: "GPT-OSS";
    readonly agentSupport: "single-step";
    readonly agentProfiles: readonly [];
    readonly transport: "chat-completions";
    readonly recommendation: "limited";
    readonly note: "Available for direct generation; the current proxy adapter has not passed multi-step tool-result continuation.";
}];
declare const DEEPSPACE_AI_DEFAULTS: {
    readonly agent: "claude-sonnet-5";
    readonly directGeneration: "claude-sonnet-5";
    readonly summarization: "claude-haiku-4-5";
};
declare const DEEPSPACE_AGENT_PROFILES: {
    readonly application: {
        readonly id: "application";
        readonly defaultModel: "claude-sonnet-5";
        readonly maxSteps: 21;
        readonly maxToolCalls: 20;
        readonly allowedTools: "application-defined";
    };
    readonly documentation: {
        readonly id: "documentation";
        readonly defaultModel: "claude-sonnet-5";
        readonly maxSteps: 21;
        readonly maxToolCalls: 20;
        readonly allowedTools: readonly ["documentation_search", "documentation_read"];
    };
};
type DeepSpaceAIModelId = (typeof DEEPSPACE_AI_MODELS)[number]['id'];
declare function getDeepSpaceAIModel(modelId: unknown): DeepSpaceAIModel | null;
declare function listDeepSpaceAgentModels(profileId?: DeepSpaceAgentProfileId): readonly DeepSpaceAIModel[];
interface ResolvedDeepSpaceAgentModel {
    modelId: string;
    provider: DeepSpaceAIProvider;
    model: DeepSpaceAIModel;
    profile: DeepSpaceAgentProfile;
}
declare function resolveDeepSpaceAgentModel(modelId: unknown, profileId?: DeepSpaceAgentProfileId): ResolvedDeepSpaceAgentModel | null;

/**
 * Routing decisions the deploy worker, the CLI, and the scaffold all depend
 * on. One home so they cannot drift — see docs/platform/app-platform-contract.md
 * for why this boundary needs one.
 */
/** Where every release serves its own identity. The deploy worker injects this
 *  asset; the CLI polls it to learn which release an edge is serving. */
declare const RELEASE_STAMP_PATH = "/.well-known/deepspace/release.json";
/**
 * What the asset layer does with a path it has no file for — Cloudflare's own
 * `not_found_handling`, restated here because both ends of a deploy have to
 * agree on the legal values.
 *
 * The app declares this and the platform honors it. It is the app's to declare
 * because it is half of a decision whose other half lives in the app's worker:
 * `none` sends misses to the worker, which is the only place that can tell a
 * client route from a missing file, and a worker written for one setting
 * misbehaves under the other. Overriding it from here would silently rewrite
 * the behavior of code the platform did not write — see
 * docs/platform/app-platform-contract.md.
 */
declare const ASSET_NOT_FOUND_HANDLING_VALUES: readonly ["none", "single-page-application", "404-page"];
type AssetNotFoundHandling = (typeof ASSET_NOT_FOUND_HANDLING_VALUES)[number];
/**
 * Applied when a deploy declares nothing.
 *
 * This is NOT Cloudflare's default (`none`) and not the value new apps ship.
 * It is what the platform hardcoded for every app before it started honoring
 * the declaration, and a deploy carrying no declaration is a CLI too old to
 * send one — necessarily paired with an app written for the old behavior.
 * Anything else here breaks every app whose CLI has not been upgraded, which
 * is the failure Rule 1 exists to prevent.
 */
declare const UNDECLARED_ASSET_NOT_FOUND_HANDLING: AssetNotFoundHandling;
declare function isAssetNotFoundHandling(value: unknown): value is AssetNotFoundHandling;
/** Stated, not inherited from the compatibility date: from 2025-04-01 the
 *  default sends navigations to the asset layer, which under
 *  `not_found_handling: "none"` would 404 every client route before the
 *  worker sees it. Required for every app, whatever it declares above. */
declare const REQUIRED_COMPATIBILITY_FLAGS: readonly ["nodejs_compat", "assets_navigation_has_no_effect"];
/** Required flags plus whatever the app added that does not contradict them. */
declare function resolveCompatibilityFlags(declared: readonly string[] | undefined): string[];
/** Routes Cloudflare hands to the worker before the asset layer answers. The
 *  agent paths are here so an app publishing nothing there 404s instead of
 *  returning its homepage. */
declare const SDK_RUN_WORKER_FIRST: readonly ["/api/*", "/ws/*", "/internal/*", "/v1/*", "/_deepspace/*", "/llms.txt", "/llms-full.txt", "/.well-known/mcp", "/.well-known/mcp.json", "/.well-known/mcp/*"];
/** Deny-list for an app's own `run_worker_first`. Strictly wider than what the
 *  platform routes worker-first; expressing it as a superset keeps the
 *  difference deliberate. */
declare const RESERVED_RUN_WORKER_FIRST: readonly string[];
/**
 * Whether the platform owns this path — so an app's worker must answer 404
 * rather than its shell when nothing is published there. Exported as a
 * predicate, not a list, because the patterns carry globs and every caller
 * matching them by hand is another copy that can drift.
 */
declare function isPlatformReservedPath(pathname: string): boolean;

/**
 * The platform endpoints this SDK's client hooks call through an app's proxy.
 *
 * The app's worker forwards these with its own identity, so the proxy is an
 * allow-list rather than a passthrough. That list has to match what the hooks
 * actually call — and only this package knows that, which is why it is stated
 * here instead of copied into each scaffold. A frozen copy in a customer's
 * repo would 404 the next hook we ship, in their browser, silently.
 *
 * The scaffold still registers the proxy itself, visibly and editably; it just
 * reads the routes from here.
 */
interface ProxyRoute {
    method: string;
    path: string;
}
declare const BROWSER_PROXY_ROUTES: ReadonlyArray<ProxyRoute>;

/**
 * Identity claims cross from an app Worker to its private room Durable Object
 * in headers. Header values are ByteStrings, while verified profile claims may
 * contain arbitrary Unicode or control characters, so carry each value as
 * UTF-8 base64url rather than writing the claim directly.
 */
interface RoomAuth {
    userId: string;
    claims: {
        name?: string;
        email?: string;
        image?: string;
    };
}
/** Strip public identity inputs and forward only verified room identity. */
declare function authenticatedRoomRequest(request: Request, auth: RoomAuth | null, identity?: {
    role?: string;
}): Request;

/**
 * Wildcard-aware CORS origin matching for the platform workers.
 *
 * Hono's array form of `cors({ origin: [...] })` is an exact `includes()` — it
 * never expands `*`. Every worker that listed `https://*.app.space` or
 * `http://localhost:*` in an array had a dead entry: the wildcard rows matched
 * nothing, silently narrowing the effective CORS surface to the literal
 * entries. This helper is the single implementation both the api and deploy
 * workers pass to Hono's function-form `origin`, so the pattern semantics
 * can't drift between them.
 *
 * `*` stands for exactly one host label or a port: it never crosses a dot or
 * a slash, so `https://*.app.space` matches `https://x.app.space` but neither
 * `https://a.b.app.space` nor `https://x.app.space.evil.com`.
 */
declare function matchOrigin(origin: string, patterns: string[]): string | null;
/**
 * The platform's standard browser-origin allow-list, derived from the
 * environment's apexes so a second constellation (staging) trusts its own
 * hosts and only its own. Both values are explicit deployment-plane config.
 * Dedupes for environments that serve both roles from one apex.
 */
declare function platformCorsPatterns(env: {
    APP_DOMAIN: string;
    PLATFORM_DOMAIN: string;
}): string[];

/**
 * Deployed-app quota defaults — the ONE copy.
 *
 * Two workers use these numbers for different jobs: the deploy worker
 * ENFORCES them at registration time, the api worker DISPLAYS them via
 * GET /api/plan-limits. They used to be independent literal sets (plus the
 * same numbers again in six wrangler [vars] blocks as overrides) and had
 * already diverged once — the display copy was missing the admin tier
 * entirely. The env vars remain the per-plane override mechanism; only the
 * fallbacks live here.
 */
declare const DEPLOYED_APPS_DEFAULTS: {
    readonly free: 1;
    readonly starter: 4;
    readonly premium: 10;
    readonly admin: 100;
};
/** Parse a quota env override; anything non-integer/negative = fallback. */
declare function parseQuotaLimit(raw: string | undefined, fallback: number): number;

/**
 * The ONE registry client. Every platform worker reaches the app-registry
 * Durable Object (hosted by the deploy worker, singleton `v1:global`) through
 * a cross-script REGISTRY binding — and before this module, each of the five
 * workers hand-rolled its own copy of the same mechanics: the instance name
 * appeared in 6 places, the `https://registry/` URL in 6, `APP_ID_RE` in 5,
 * and `RegistryClientError` + `registryErrorJson` existed byte-identical in
 * two workers. Copies that must agree and nothing enforcing it.
 *
 * This module owns the MECHANICS: instance name, stub lookup, the wire call,
 * the error type, and the standard route mapping. Each worker still declares
 * its own typed convenience wrapper listing only the actions it uses — that
 * subset is genuinely per-worker; the plumbing is not.
 */
/** The singleton registry instance — one DO holds every app/route/collaborator. */
declare const REGISTRY_INSTANCE = "v1:global";
/** Public app ids have one canonical ULID-minted shape. */
declare const APP_ID_RE: RegExp;
declare const STRICT_APP_ID_RE: RegExp;
/** Internal physical locators survive identity migration and are not public ids. */
declare const RESOURCE_ID_RE: RegExp;
/** A 26-char ULID (48-bit ms timestamp + 80 random bits, Crockford base32) —
 *  the id shape shared by app ids (`app_…`) and workspace ids (`ws_…`). */
declare function mintUlid(now?: number): string;
/** Mint a fresh app id: `app_` + 26-char ULID. App ids are minted ONLY by the
 *  deploy worker's authenticated `POST /api/apps/mint`, which registers the id
 *  to its caller in the same step — an id with no owner never exists. */
declare function mintAppId(now?: number): string;
declare class RegistryClientError extends Error {
    readonly code: string;
    readonly status: number;
    constructor(message: string, code: string, status: number);
}
declare function registryStub(ns: DurableObjectNamespace): DurableObjectStub;
/**
 * One registry action over the wire. Non-2xx answers throw
 * {@link RegistryClientError} carrying the DO's structured `code` (or
 * `'error'` for a transport-shaped body) — callers distinguish a registry-
 * REPORTED miss (`code === 'not_found'`) from an outage by that code, never
 * by treating every throw as "not found".
 */
declare function callRegistry<T>(stub: DurableObjectStub, body: {
    action: string;
} & Record<string, unknown>): Promise<T>;
/** Standard mapping of a registry failure onto a route response. */
declare function registryErrorJson(c: {
    json: (body: unknown, status?: number) => Response;
}, err: unknown): Response;

/**
 * Tools API Types and Definitions
 *
 * MCP-like interface for agent tool calls.
 * Built-in tools for records, schemas, users, and Yjs documents.
 */
interface ToolSchema {
    name: string;
    description: string;
    params: Record<string, {
        type: 'string' | 'number' | 'boolean' | 'object' | 'array';
        description: string;
        required?: boolean;
        default?: unknown;
    }>;
}
/**
 * Discriminated union so callers don't have to guard on `error` being
 * defined when `success` is false — TS enforces the invariant.
 */
type ToolResult = {
    success: true;
    data?: unknown;
} | {
    success: false;
    error: string;
};
/**
 * Page size the assistant defaults to for `records.query` when it omits
 * `limit`. Keeps a model-issued unbounded scan from blowing the tool-result
 * byte cap and gives the model a usable first page. Raise `limit` to page
 * through more (still subject to the cap; see
 * `DEFAULT_CONTEXT_CONFIG.toolResultCap` / `capToolResultSize`, which truncates
 * oversized pages gracefully rather than dropping them).
 *
 * Applied by the AI tool layer via `applyAiToolDefaults`, never by the shared
 * tools-api dispatch, so internal record readers (chat history, cron, app
 * `actions.query`) stay unbounded.
 */
declare const DEFAULT_QUERY_LIMIT = 50;
/**
 * Page size `records.deleteWhere` uses when the caller omits `limit`, and the
 * ceiling it clamps any larger `limit` to.
 *
 * The tool exists so a cascade costs one subrequest per *page* instead of one
 * per row (see `deleteChatCascade`); the ceiling keeps a single call's SQL and
 * delete broadcasts bounded, and callers page by repeating the call until it
 * reports fewer deletions than the page size.
 */
declare const DEFAULT_DELETE_WHERE_LIMIT = 100;
declare const MAX_DELETE_WHERE_LIMIT = 500;
/**
 * Fill in assistant-only parameter defaults for a built-in tool call.
 *
 * Applied by the AI tool layer (`buildTools`) before a model-issued tool call
 * is dispatched, so the default only affects calls the assistant makes.
 * `records.query` doubles as the SDK's general record-read primitive (chat
 * history, cron, app `actions.query`); those callers reach the tools dispatch
 * directly and must return every row, so this default must not live in the
 * dispatch itself. Pure and non-mutating.
 */
declare function applyAiToolDefaults(toolName: string, params: Record<string, unknown>): Record<string, unknown>;
/**
 * Built-in tool definitions for record, schema, user, and Yjs operations.
 */
declare const BUILT_IN_TOOLS: ToolSchema[];

/**
 * App-files limits, chunk planning, and failure reading — shared by every
 * caller of the files API: the browser hook (`client/storage/useR2Files.ts`),
 * the CLI (`cli/lib/app-files-api.ts`), the server handler
 * (`server/utils/scoped-r2-files.ts`), and the docs that quote them.
 *
 * There are three numbers here and they answer three different questions.
 * Conflating them is what produced the old 25 MiB per-file ceiling: that was
 * never a product decision, it was the size of one HTTP request leaking out as
 * a rule about files. A request is bounded by physics — Cloudflare rejects an
 * oversized body before any worker runs, and the worker's isolate is ~128 MiB.
 * A FILE is not, once it travels as a sequence of bounded requests.
 *
 * The other half of this module is failure reading. An upload refused at the
 * edge answers with a Cloudflare HTML page, which every caller used to feed
 * straight into `JSON.parse` and report as "Unexpected token '<' … is not
 * valid JSON". `describeFilesFailure` exists to make that impossible.
 */
/**
 * The largest single file the app-files API accepts.
 *
 * Reachable only through the multipart transport: a file above
 * {@link UPLOAD_PART_BYTES} is uploaded as a sequence of parts, so no request
 * and no isolate ever holds more than one part. Enforced by the shared handler
 * (`server/utils/scoped-r2-files.ts`) twice — once at init against the
 * declared total, so an impossible upload fails before a byte moves, and again
 * at complete against the assembled object, because the declared total is
 * client-supplied. Callers check it locally too, but only to fail early;
 * skipping the client check cannot widen what is accepted.
 */
declare const MAX_APP_FILE_BYTES: number;
/**
 * The most any ONE request body may carry — a whole small file on the
 * single-request path, or one part on the multipart path.
 *
 * This is the transport's real physical bound, and the only thing 25 MiB ever
 * meant. Above it the worker risks exhausting its isolate holding the body;
 * well above it (~100 MB) Cloudflare refuses the request before the worker
 * runs at all, which is why callers must read failures as text first.
 */
declare const MAX_UPLOAD_REQUEST_BYTES: number;
/**
 * The part size clients chunk at, and the threshold above which they must.
 *
 * Below the {@link MAX_UPLOAD_REQUEST_BYTES} bound with headroom for the
 * request envelope, and comfortably inside R2's own part rules: parts must be
 * at least 5 MiB and every non-final part must be exactly the same size
 * (R2 errors 10011 / 10048). The server advertises this at init — a client
 * chunks at the size it is told, not at this constant, so the number can move
 * without stranding older callers mid-upload.
 */
declare const UPLOAD_PART_BYTES: number;
/**
 * The highest part number the server accepts.
 *
 * The server derives the only valid part number and byte length from the
 * declared total and {@link UPLOAD_PART_BYTES}. The maximum part count is
 * therefore the exact number needed to reach the file ceiling.
 *
 * R2 allows 10,000 parts, so this is far inside what the API permits.
 */
declare const MAX_UPLOAD_PARTS: number;
/**
 * The customer-visible storage schedule, in bytes, PER ACCOUNT — the total an
 * owner's uploaded files may occupy across every app they own, not a budget
 * each app gets separately. This is the number the billing page advertises.
 *
 * Admitted by the shared files handler (`server/utils/scoped-r2-files.ts`),
 * which sums the owner's apps rather than the one being written to.
 *
 * It deliberately does NOT govern the repo store — see
 * `REPO_STORE_LIMIT_BYTES` below, and docs/platform/r2-storage.md.
 */
declare const ACCOUNT_STORAGE_LIMIT_BYTES: {
    readonly test: 0;
    readonly free: number;
    readonly starter: number;
    readonly premium: number;
    readonly admin: number;
};
/** The account storage limit for a billing tier; unknown or missing tiers get free. */
declare function storageLimitForTier(tier: string | null | undefined): number;
/**
 * The repo store's budget, per app, flat across every tier.
 *
 * Git packs, retained rollback bundles, and stored deploy assets are platform
 * bookkeeping, not something a customer buys — so this is a working ceiling,
 * not an entitlement, and it is deliberately small. An app that cannot fit its
 * SOURCE plus a few rollback bundles in this has something in the wrong place:
 * user uploads belong in the app-files allocation above, which is what the
 * account schedule sizes.
 *
 * Being flat is the point. Tying it to the tier table meant every raise to the
 * customer-facing number silently multiplied platform-side storage per app,
 * and made a push depend on a billing lookup that could refuse it.
 */
declare const REPO_STORE_LIMIT_BYTES: number;
/** The one storage-quota refusal sentence. `usedBytes` is net of any object
 *  the upload replaces, so an upsert is charged only for its growth. */
declare function storageQuotaMessage(incomingBytes: number, usedBytes: number, limitBytes: number): string;
/**
 * The largest single file a deploy may ship as a static asset.
 *
 * Cloudflare Static Assets refuses anything larger, so this is a hard edge of
 * the platform rather than a policy dial — which is why the CLI may check it
 * locally. It lives here so the deploy worker and the CLI cannot drift; the
 * per-DEPLOY total is deliberately NOT here, because it is env-configurable
 * per environment and only the server can know it.
 */
declare const MAX_DEPLOY_ASSET_FILE_BYTES: number;
declare function formatBytes(bytes: number): string;

/**
 * Everything the files handler needs to enforce one account allocation.
 *
 * `quotaKey` is required because an exact scan followed by an uncoordinated
 * write cannot enforce a limit under concurrency. Callers that do not want a
 * quota omit `storage`; callers that do want one must name its serialized
 * summary.
 */
interface StorageAdmission {
    /** The app prefix receiving this request's write. */
    prefix: string;
    /** Internal R2 key for the account's ETag-serialized usage summary. */
    quotaKey: string;
    /** Resolve the account's limit. `null` fails writes closed. */
    limitBytes: () => Promise<number | null>;
    /** Resolve the other app prefixes in the account. `null` fails closed. */
    siblingPrefixes?: () => Promise<string[] | null>;
}

/**
 * Shared Scoped R2 Files Handler
 *
 * Provides a secure, prefix-scoped R2 files API that enforces:
 *   1. All R2 keys are validated against the resolved prefix (no bypass)
 *   2. Path traversal (`..`, `.`) is rejected
 *   3. Mutations (upload/delete) require authentication by default
 *
 * Each worker provides a `resolvePrefix` callback for its scoping rules.
 * The security invariants are enforced here once — not per-worker.
 *
 * Routes:
 *   POST   /api/files/upload              → upload one file in one request
 *   POST   /api/files/multipart           → begin a chunked upload
 *   PUT    /api/files/multipart/part      → send one part
 *   POST   /api/files/multipart/complete  → assemble the parts
 *   DELETE /api/files/multipart           → abandon a chunked upload
 *   GET    /api/files                     → list   (prefix + optional user prefix)
 *   GET    /api/files/:key                → download (validated against prefix; Range-aware)
 *   HEAD   /api/files/:key                → the download's headers, no body
 *   DELETE /api/files/:key                → delete   (validated against prefix)
 *
 * ## One transport discipline
 *
 * Both upload paths obey the rule the deploy asset transport established
 * (`docs/platform/deploy-asset-transport.md`): nothing here
 * ever holds more than one bounded request in memory. The single-request path
 * exists so a small file still costs one round trip; above
 * {@link UPLOAD_PART_BYTES} a file travels as parts, each streamed into R2
 * through a `FixedLengthStream` with a required `Content-Length`. That is why
 * a 1 GiB file is admissible in a ~128 MiB isolate.
 *
 * Validation is identical on both paths and on both mounts, because it lives
 * here: the prefix scoping, the traversal check, the MIME refusals, and both
 * size bounds. A hand-rolled request that skips every client guard reaches
 * exactly these checks.
 */

interface ScopeContext {
    userId: string | null;
    url: URL;
}
type PrefixResult = {
    prefix: string;
    excludedPrefixes?: readonly string[];
    error?: undefined;
} | {
    prefix?: undefined;
    error: string;
};
interface ScopedR2Config {
    /**
     * Resolve the R2 key prefix for the given scope.
     * Called with the `?scope=` query param value (default: 'self').
     */
    resolvePrefix: (scope: string, ctx: ScopeContext) => PrefixResult;
    /**
     * Require a non-null userId for upload and delete.
     * @default true
     */
    requireAuthForMutations?: boolean;
}
/**
 * The storage-quota contract for one allocation, supplied per request by the
 * mount. The handler is the enforcer; the mount only knows whose limit
 * applies.
 */
interface ScopedR2Auth {
    userId: string | null;
    /** Absent = no quota on this mount (e.g. an app's own bucket). */
    storage?: StorageAdmission;
    /** Account-wide quota details are private to an authorized owner surface. */
    includeStorageUsage?: boolean;
}
type ScopedR2Handler = (request: Request, url: URL, bucket: R2Bucket, auth: ScopedR2Auth) => Promise<Response>;
declare function isFilesVerbPath(method: string, subpath: string): boolean;
/**
 * Create a scoped R2 files handler.
 *
 * Security guarantees:
 *   - Download/delete keys are validated to start with the resolved prefix
 *   - Path traversal (`..`) is rejected at the entry point
 *   - Mutations require a non-null userId by default
 *
 * @returns A handler function: `(request, url, bucket, auth) => Promise<Response>`
 */
declare function createScopedR2Handler(config: ScopedR2Config): ScopedR2Handler;

/**
 * Platform API error normalization — the one chokepoint that turns the
 * api-worker's error envelope into a render-safe + branch-safe shape.
 *
 * The platform emits errors as `{ error: <machine slug>, message?: <human>,
 * ...details }` (e.g. 402 `{ error: 'insufficient_credits', message:
 * 'Insufficient credits.', availableCredits, requiredCredits }`; some routes
 * send the bare slug with no `message` at all, e.g. 409
 * `{ error: 'owner_connect_not_ready' }`). Consumers must never show the slug
 * to a person or make an agent parse the sentence — this module separates the
 * two once, for the integration client, server actions, billing hooks, and the
 * CLI.
 */
/** One structured validation issue (Zod shape) from a `validation_failed` response. */
interface ApiErrorIssue {
    path?: string[];
    message: string;
    code?: string;
}
/** A platform error response, normalized. */
interface NormalizedApiError {
    /**
     * Human-readable text, safe to render:
     * `message ?? non-slug error ?? humanized(slug) ?? slug`.
     */
    error: string;
    /** The machine slug (e.g. 'insufficient_credits') for branching — never render it. */
    code?: string;
    /** HTTP status of the response; 0 when no HTTP response arrived (transport failure). */
    status: number;
    /** Structured fields the server sent alongside the error (e.g. `availableCredits`). */
    details?: Record<string, unknown>;
    /** Zod issues accompanying a `validation_failed` response. */
    issues?: ApiErrorIssue[];
}
/**
 * Normalize a platform error body (parsed JSON, or anything else) plus its
 * HTTP status into a {@link NormalizedApiError}. Pass status 0 for failures
 * that never produced an HTTP response.
 */
declare function normalizeApiError(status: number, body: unknown): NormalizedApiError;

/**
 * Server Action Types
 *
 * Types for app-defined server actions that run in the site worker.
 * Actions bypass user RBAC via the X-App-Action header — the app's
 * server-side code IS the trust boundary.
 */

/**
 * Discriminated result wrapper. Narrowing on `.success` lets TS know
 * `.data` is present in the success branch and `.error` in the failure
 * branch, so callers can't read the wrong field by accident.
 *
 * `TData` is the per-operation data shape — `tools.query` returns
 * `{ records, count }`, `tools.get` returns `{ record }`, etc. Apps
 * that compose their own server actions can specialize further.
 */
type ActionResult<TData = unknown> = {
    success: true;
    data: TData;
    error?: never;
} | {
    success: false;
    data?: never;
    /** Human-readable error, safe to render directly. */
    error: string;
    /** Machine slug for branching, when the failing tool supplied one. */
    code?: string;
    /** HTTP status from an upstream platform request, when applicable. */
    status?: number;
    /** Structured fields supplied with the error response. */
    details?: Record<string, unknown>;
    /** Validation issues supplied with a `validation_failed` response. */
    issues?: ApiErrorIssue[];
};
/** Shape of the data field for `tools.query`. */
interface QueryActionData<T = Record<string, unknown>> {
    records: Array<RecordResult & {
        data: T;
    }>;
    count: number;
}
/** Shape of the data field for `tools.get`. */
interface GetActionData<T = Record<string, unknown>> {
    record: RecordResult & {
        data: T;
    };
}
/** Shape of the data field for `tools.create`/`update`/`remove`. */
interface MutateActionData {
    recordId: string;
}
interface ActionTools {
    /**
     * Insert a new record. When `recordId` is omitted the DO generates one
     * (typical). Pass `recordId` to upsert against a known key — useful
     * for `users` where the row id must equal the auth user's id so
     * `tools.get('users', userId)` resolves.
     */
    create<T extends Record<string, unknown> = Record<string, unknown>>(collection: string, data: T, recordId?: string): Promise<ActionResult<MutateActionData>>;
    update<T extends Record<string, unknown> = Record<string, unknown>>(collection: string, recordId: string, data: Partial<T>): Promise<ActionResult<MutateActionData>>;
    remove(collection: string, recordId: string): Promise<ActionResult<MutateActionData>>;
    /**
     * Delete every record matching `where`, in one bounded batch — the cascade
     * primitive, so draining a set costs one subrequest per page instead of one
     * per row. Deletes at most `limit` (default 100, max 500) and returns
     * `{ deleted }`; repeat the same call until `deleted` is below the limit to
     * drain a larger set.
     *
     * `where` must be non-empty and every key must name a real field
     * (`recordId`, `createdBy`, or a schema column) — an unknown key is refused,
     * not ignored, so this can never truncate a whole collection.
     */
    deleteWhere(collection: string, where: Record<string, unknown>, limit?: number): Promise<ActionResult<{
        deleted: number;
    }>>;
    get<T extends Record<string, unknown> = Record<string, unknown>>(collection: string, recordId: string): Promise<ActionResult<GetActionData<T>>>;
    query<T extends Record<string, unknown> = Record<string, unknown>>(collection: string, options?: {
        where?: Record<string, unknown>;
        orderBy?: string;
        orderDir?: 'asc' | 'desc';
        limit?: number;
    }): Promise<ActionResult<QueryActionData<T>>>;
    /**
     * Call an integration endpoint (e.g. 'openai/chat-completion') via the
     * api-worker. On success, `result.data` is the integration's response
     * body directly — there is no `.response` wrapper. So an OpenAI call
     * yields `result.data.choices`, a Freepik image call yields
     * `result.data.images`, etc. On failure, `result.error` is human-readable;
     * branch on `result.code` and inspect `status`, `details`, or `issues` when
     * present.
     */
    integration<T = unknown>(endpoint: string, data?: unknown): Promise<ActionResult<T>>;
    /**
     * Insert or refresh the `users` row for an authenticated caller.
     * Mirrors the WS-connect registerUser flow — useful for CLI-only
     * actions (e.g. publishing via `deepspace foo publish`) where the
     * caller may never have opened the web app and has no `users` row
     * yet. Bypasses SYSTEM_MANAGED column stripping so name/email/
     * imageUrl are actually written.
     *
     * Defaults `userId` to the action's caller. Pass `isAdmin: true` only
     * if the caller's platform-tier role is admin (worker.ts should
     * derive this from the verified JWT — never trust client input).
     */
    registerUser(opts: {
        userId?: string;
        name?: string;
        email?: string;
        imageUrl?: string;
        isAdmin?: boolean;
    }): Promise<ActionResult<{
        user: {
            id: string;
            name: string;
            email: string;
            imageUrl?: string;
            role: string;
        };
    }>>;
}
/**
 * `TEnv` lets apps type the worker-scoped env object passed to the
 * action handler. Defaults to a loose `Record<string, unknown>` so
 * unparameterized handlers still compile; apps that want strict typing
 * can do `ActionHandler<Env>` where Env is their own worker's bindings
 * interface.
 */
interface ActionContext<TEnv = Record<string, unknown>> {
    userId: string;
    params: Record<string, unknown>;
    tools: ActionTools;
    /**
     * The worker's env bindings. Used by actions that need access to
     * secrets, bindings, or platform-injected values like `OWNER_USER_ID`
     * (e.g. for owner-only action gating).
     */
    env: TEnv;
    /**
     * The caller's raw JWT. Forward this on outbound requests that need to
     * impersonate the user (e.g. checking `/api/apps` ownership on the
     * deploy worker, where the user — not the app owner — should be billed
     * / authorized).
     */
    callerJwt: string;
}
type ActionHandler<TEnv = Record<string, unknown>> = (ctx: ActionContext<TEnv>) => Promise<ActionResult>;

/**
 * Upstream worker proxy helpers.
 *
 * App workers reach the platform's other workers (api, platform, auth) through
 * one of two transports:
 *
 *   1. **Service binding** (`env.API_WORKER` / `env.PLATFORM_WORKER`) — the
 *      preferred path in production. Configured via wrangler `[[services]]`.
 *      Cross-worker calls over plain `*.workers.dev` URLs return Cloudflare
 *      error 1042 in production, so the binding is the only working path
 *      in deployed apps.
 *
 *   2. **HTTPS URL** (`env.API_WORKER_URL` / `env.PLATFORM_WORKER_URL`) — the
 *      fallback used in local development. `deepspace dev start` writes these
 *      into `.dev.vars`, which `wrangler dev` exposes as env vars. Service
 *      bindings don't work cross-process under `wrangler dev` for SDK apps,
 *      so the URL is the only working path in dev.
 *
 * The auth-worker has no service binding even in production — its responses
 * carry `Set-Cookie` headers we want preserved verbatim, which we get for
 * free over plain HTTPS. So `authWorkerFetch` is URL-only; the helper exists
 * for surface consistency, not to switch transports.
 *
 * Each helper:
 *   - Prefers the binding if present, falls back to the URL otherwise.
 *   - Throws an actionable Error if neither is configured. No silent 502s.
 *   - Forwards `init` (method/headers/body) verbatim to the upstream worker.
 *
 * History: a previous in-tree helper folded the binding/URL fallback into
 * the AI module's `resolveTransport`. Inline call sites in the starter
 * template (integrations, files, debug) used `c.env.X.fetch(...)` directly,
 * which broke `npx deepspace dev start` for any app calling those routes — the
 * binding is undefined locally, so the fetch threw. These helpers
 * standardize on the same shape `resolveTransport` had, so every upstream
 * call works in both dev and prod.
 */
/**
 * Env shape required by `apiWorkerFetch`. App workers should extend this
 * (the starter template does) so the helper can be called with `c.env`.
 */
interface ApiWorkerEnv {
    /** Cloudflare service binding for the api-worker. Preferred. */
    API_WORKER?: Fetcher;
    /** HTTPS URL for the api-worker. Used when the binding is absent (dev). */
    API_WORKER_URL?: string;
}
/** Env shape required by `platformWorkerFetch`. */
interface PlatformWorkerEnv {
    /** Cloudflare service binding for the platform-worker. Preferred. */
    PLATFORM_WORKER?: Fetcher;
    /** HTTPS URL for the platform-worker. Used when the binding is absent. */
    PLATFORM_WORKER_URL?: string;
}
/** Env shape required by `authWorkerFetch`. URL-only. */
interface AuthWorkerEnv {
    /** HTTPS URL for the auth-worker. Always required. */
    AUTH_WORKER_URL?: string;
}
/**
 * Fetch the api-worker. Prefers the `API_WORKER` service binding, falls
 * back to `API_WORKER_URL` over HTTPS.
 *
 * `path` is treated as path-only — any host in a passed-in URL is
 * stripped and replaced. This matches how `c.env.API_WORKER.fetch(...)`
 * already worked in the starter template (the host was always a
 * placeholder like `api-worker`).
 */
declare function apiWorkerFetch(env: ApiWorkerEnv, path: string, init?: RequestInit): Promise<Response>;
/**
 * Fetch the platform-worker. Prefers the `PLATFORM_WORKER` service binding,
 * falls back to `PLATFORM_WORKER_URL` over HTTPS.
 *
 * Accepts a `Request` instance directly so callers can hand off
 * `c.req.raw`-derived requests with their original method/headers/body
 * intact. (`/api/files/*` does this — it forwards the caller's body
 * stream verbatim.)
 */
declare function platformWorkerFetch(env: PlatformWorkerEnv, pathOrRequest: string | Request, init?: RequestInit): Promise<Response>;
/**
 * Fetch the auth-worker over HTTPS. URL-only — there is no auth-worker
 * service binding, by design (we want plain-HTTP cookie semantics).
 *
 * Kept as a helper for surface symmetry with `apiWorkerFetch` /
 * `platformWorkerFetch`. Throws if `AUTH_WORKER_URL` is unset.
 */
declare function authWorkerFetch(env: AuthWorkerEnv, path: string, init?: RequestInit): Promise<Response>;

/**
 * Cron System — Server-Side Scheduled Tasks
 *
 * Provides CronContext for miniapp cron handlers and buildCronContext
 * to construct it from worker environment bindings.
 *
 * CronContext gives handlers access to:
 *   - records: Query/create/update/delete via RecordRoom tools API
 *   - integrations: Call platform integration endpoints, billed to the app owner
 *   - ownerUserId: The app owner's user ID
 */

/** Context passed to cron handler functions */
interface CronContext {
    /** RecordRoom data access (queries the DO directly via tools API) */
    records: {
        query(collection: string, opts?: {
            where?: Record<string, unknown>;
            limit?: number;
        }): Promise<unknown[]>;
        create(collection: string, data: Record<string, unknown>): Promise<unknown>;
        update(collection: string, recordId: string, data: Record<string, unknown>): Promise<unknown>;
        delete(collection: string, recordId: string): Promise<unknown>;
    };
    /**
     * Call a platform integration endpoint (e.g. "openai/chat-completion",
     * "fal/run-model"). Billed to the app owner using the same
     * APP_OWNER_JWT the rest of the SDK uses for server-side billed calls.
     */
    integrations: {
        call(endpoint: string, params?: Record<string, unknown>): Promise<unknown>;
    };
    /** App owner's user ID */
    ownerUserId: string;
}
/** Environment bindings needed by buildCronContext */
interface CronEnv extends ApiWorkerEnv {
    RECORD_ROOMS: DurableObjectNamespace;
    /**
     * Long-lived app-owner JWT minted at deploy time. Required for
     * `integrations.call()` so the call is billed to the app owner.
     * Optional here so apps that don't use integrations from cron can omit
     * it without a type error; missing-at-call-time throws a clear message.
     */
    APP_OWNER_JWT?: string;
}
/**
 * Build a CronContext from worker environment bindings.
 *
 * @param env - Worker environment with RECORD_ROOMS DO namespace, APP_OWNER_JWT, and an api-worker transport (API_WORKER binding or API_WORKER_URL)
 * @param ownerUserId - App owner's user ID (for RBAC and billing)
 * @param roomId - RecordRoom ID (defaults to 'default')
 */
declare function buildCronContext(env: CronEnv, ownerUserId: string, roomId?: string): CronContext;

/**
 * Standard DeepSpace role constants.
 *
 * Every DeepSpace app uses the same three roles.
 * Apps can import these instead of defining them locally.
 */
declare const ROLES: {
    readonly VIEWER: "viewer";
    readonly MEMBER: "member";
    readonly ADMIN: "admin";
};
type Role = (typeof ROLES)[keyof typeof ROLES];

interface AppRoleEnv {
    RECORD_ROOMS: DurableObjectNamespace;
    DEEPSPACE_APP_ID: string;
    OWNER_USER_ID: string;
}
interface AppMembership {
    /** True when the caller's row exists in the app's canonical users collection. */
    member: boolean;
    role: Role;
}
/**
 * Resolve a user's membership and role from the app's canonical users
 * collection in one read. This is the single definition of "is this user in
 * the app" — gate new surfaces with it rather than re-deriving membership
 * from another tool call. Returns null when the read itself failed (room
 * unreachable, aborted): callers must treat that as "could not verify", never
 * as "not a member".
 */
declare function resolveAppMembership(env: AppRoleEnv, userId: string, signal?: AbortSignal): Promise<AppMembership | null>;
/** Resolve a user's current role from the app's canonical users collection. */
declare function resolveAppRole(env: AppRoleEnv, userId: string): Promise<Role>;

/**
 * AI provider helpers — create Vercel AI SDK providers that route through
 * the DeepSpace API worker proxy for per-user billing.
 *
 * Supported providers: anthropic, openai, cerebras.
 *
 * The API worker can be reached in two ways:
 *   - Service binding `env.API_WORKER` (Cloudflare Fetcher) — preferred in
 *     production if the app has declared the binding in wrangler.toml.
 *   - HTTPS URL `env.API_WORKER_URL` — used in local dev and in production
 *     for apps that don't declare the binding. `deepspace dev start` writes this
 *     into `.dev.vars` automatically.
 *
 * Auth is automatic by default:
 *   - For server-side autonomous calls (cron, DO alarms, background agents),
 *     the helper reads the long-lived `env.APP_OWNER_JWT` minted at deploy
 *     time (or by `deepspace dev start` in local development) and uses it for the
 *     proxy auth header. The owner is billed automatically via the JWT sub.
 *   - For user-initiated calls (e.g. an `/api/ai/chat` route handling a
 *     browser request), pass `options.authToken` explicitly with the user's
 *     own JWT so the call is billed to the user.
 *
 * Usage:
 *
 *   // Server-side autonomous — no auth config needed
 *   import { createDeepSpaceAI } from 'deepspace/worker'
 *   const cerebras = createDeepSpaceAI(env, 'cerebras')
 *   const result = await generateText({ model: cerebras('llama-3.3-70b'), ... })
 *
 *   // User-initiated (inside a request handler)
 *   const jwt = c.req.header('Authorization')!.slice(7)
 *   const anthropic = createDeepSpaceAI(c.env, 'anthropic', { authToken: jwt })
 */

/**
 * Model factory: `(modelId) => LanguageModel`. The explicit return type
 * keeps tsup's DTS build from leaking unportable `.pnpm/@ai-sdk+provider/...`
 * paths into the published `dist/index.d.ts`.
 */
type DeepSpaceModelFactory = (modelId: string) => LanguageModel;
interface DeepSpaceAIEnv extends ApiWorkerEnv {
    /**
     * Long-lived owner-scoped JWT minted at deploy time (or by `deepspace dev start`).
     * Used as the default proxy auth token when `options.authToken` is absent.
     * Bills the app owner.
     */
    APP_OWNER_JWT?: string;
}
interface DeepSpaceAIOptions {
    /**
     * Explicit auth token for this call. Use this for user-initiated flows
     * where the caller's own JWT should be billed. If omitted, the helper
     * falls back to `env.APP_OWNER_JWT` (bills the app owner).
     *
     * Billing is always against the JWT subject — to bill a different user,
     * pass a JWT whose subject is that user. The proxy does not accept any
     * client-supplied billing override.
     */
    authToken?: string;
}
/**
 * Build an AI SDK provider that routes through the DeepSpace API worker.
 *
 * Resolves the transport (service binding or URL) and the auth token
 * (explicit or `env.APP_OWNER_JWT`) automatically. Throws a clear error if
 * either is unconfigured.
 */
declare function createDeepSpaceAI(env: DeepSpaceAIEnv, provider: DeepSpaceAIProvider, options?: DeepSpaceAIOptions): DeepSpaceModelFactory;

type StreamTextOptions<TOOLS extends ToolSet> = Parameters<typeof streamText<TOOLS>>[0];
type DeepSpaceAgentStreamOptions<TOOLS extends ToolSet> = Omit<StreamTextOptions<TOOLS>, 'model' | 'providerOptions' | 'stopWhen'> & {
    profile: DeepSpaceAgentProfileId;
    modelId?: unknown;
    authToken?: string;
};
interface DeepSpaceAgentStream<TOOLS extends ToolSet> {
    selection: ResolvedDeepSpaceAgentModel;
    result: StreamTextResult<TOOLS, never>;
}
declare class DeepSpaceAgentModelError extends Error {
    readonly modelId: unknown;
    readonly profile: DeepSpaceAgentProfileId;
    readonly code = "unsupported_agent_model";
    constructor(modelId: unknown, profile: DeepSpaceAgentProfileId);
}
declare class DeepSpaceAgentProfileError extends Error {
    readonly profile: DeepSpaceAgentProfileId;
    readonly toolName: string;
    readonly code = "agent_profile_violation";
    constructor(profile: DeepSpaceAgentProfileId, toolName: string);
}
/** The sole provider/model/tool-loop implementation for every DeepSpace agent surface. */
declare function streamDeepSpaceAgent<TOOLS extends ToolSet>(env: DeepSpaceAIEnv, options: DeepSpaceAgentStreamOptions<TOOLS>): DeepSpaceAgentStream<TOOLS>;
interface DeepSpaceAgentDiagnosticContext {
    profile?: DeepSpaceAgentProfileId;
    provider?: string;
    modelId?: string;
}
/** Preserve safe structured provider diagnostics in bounded Worker logs. */
declare function deepSpaceAgentErrorSummary(error: unknown, context?: DeepSpaceAgentDiagnosticContext): string;

/**
 * Composio tools for the Vercel AI SDK.
 *
 * Turns the platform's Composio integration into ready-to-use Vercel AI SDK
 * tools, so an agent (or the DeepSpace AI chat) can take actions on a user's
 * connected apps. Each returned tool's `execute()` calls our own
 * `composio/execute-tool` endpoint through the api-worker proxy, so our auth
 * and per-user billing apply. This is the managed-proxy equivalent of
 * Composio's `@composio/vercel` provider, which talks straight to Composio.
 *
 * `authToken` must be the END USER's JWT: Composio resolves the user's
 * connected accounts by the JWT subject, and that user is billed.
 *
 * Usage (inside a request handler, e.g. /api/ai/chat):
 *
 *   import { composioTools, createDeepSpaceAI } from 'deepspace/worker'
 *   const jwt = c.req.header('Authorization')!.slice(7)
 *   const tools = await composioTools(c.env, { toolkit: 'gmail', authToken: jwt })
 *   const ai = createDeepSpaceAI(c.env, 'anthropic', { authToken: jwt })
 *   const result = streamText({ model: ai('claude-sonnet-5'), prompt, tools })
 *
 * Merge with your own tools: `tools: { ...buildTools(executor), ...composio }`.
 */

interface ComposioToolsOptions {
    /** End user's JWT. Required: the tools run as this user and bill them. */
    authToken: string;
    /** Restrict to one toolkit (e.g. 'gmail', 'github'). */
    toolkit?: string;
    /** Explicit tool slugs to expose (e.g. ['GMAIL_SEND_EMAIL']). */
    tools?: string[];
    /** Natural-language search to pick relevant tools. */
    search?: string;
    /** Cap how many tools are exposed (default 20). Keep small: the LLM sees them all. */
    limit?: number;
}
/**
 * Fetch Composio tools for the given scope and return them as a Vercel AI SDK
 * `ToolSet`. One `list-tools` call provides each tool's JSON Schema; each tool
 * executes via `composio/execute-tool` as the authenticated user.
 */
declare function composioTools(env: ApiWorkerEnv, options: ComposioToolsOptions): Promise<ToolSet>;

/**
 * captureScreenshot — call platform-worker /internal/screenshot.
 *
 * Apps don't ship CF Browser Rendering bindings or puppeteer in their
 * own bundle. The platform holds the binding; consumers call this
 * helper to get PNG bytes for a URL.
 *
 * The platform enforces HTTPS, a DeepSpace host allowlist, a per-app rate
 * limit, and one fixed viewport-only capture profile. Returns `null` on any
 * non-2xx — callers should treat that as "no preview available".
 *
 * Auth is the same HMAC-of-appId pattern `/internal/files` uses:
 *   x-app-identity-token = hmac(PLATFORM_IDENTITY_SECRET, DEEPSPACE_APP_ID)
 *   x-app-id             = DEEPSPACE_APP_ID
 *
 * Apps already have both as bindings (APP_IDENTITY_TOKEN + DEEPSPACE_APP_ID),
 * so this helper is a thin wrapper — no extra secrets to manage.
 */

interface ScreenshotEnv extends PlatformWorkerEnv {
    /** Immutable app id — the identity the platform verifies (HMAC input). */
    DEEPSPACE_APP_ID: string;
    /** Absent until the app's first deploy injects it — see appendAppIdentity. */
    APP_IDENTITY_TOKEN?: string;
}
interface ScreenshotResult {
    /** PNG bytes. */
    body: ArrayBuffer;
    /** `image/png`. */
    contentType: string;
}
/**
 * Capture a screenshot of `url` and return the PNG bytes.
 *
 * Returns null on capture failure (target unreachable, timeout, BR
 * binding misconfigured platform-side). The platform logs a generic failure
 * without target details; callers should surface their own fallback UX.
 */
declare function captureScreenshot(env: ScreenshotEnv, url: string): Promise<ScreenshotResult | null>;

/**
 * Chat context pipeline — keeps the per-request payload to the LLM bounded.
 *
 * `prepareMessagesWithCompaction` runs before `streamText`: truncate old tool
 * results, apply a cached summary if available, otherwise summarize the older
 * half of history when over budget. Falls back to a sliding window if
 * summarization fails. `capToolResultSize` caps individual tool calls.
 */

interface ChatTurn {
    id?: string;
    role: 'user' | 'assistant' | 'system';
    content: string;
    parts?: unknown[];
}
type Summarizer = (messages: ChatTurn[]) => Promise<string>;
interface ChatContextConfig {
    contextBudget: number;
    toolResultCap: number;
    keepRecentToolResults: number;
    minKept: number;
}
declare const DEFAULT_CONTEXT_CONFIG: ChatContextConfig;
declare function totalChars(messages: ChatTurn[]): number;
/**
 * Replace older tool-result payloads with a small marker. Keeps the last
 * `keepRecent` tool results intact. Errors (`success: false`) are preserved —
 * they're small and the agent needs them for reasoning.
 */
declare function truncateOldToolResults(messages: ChatTurn[], keepRecent: number): ChatTurn[];
/**
 * Drop oldest messages until total character count is under `charCap`,
 * never going below `minKept` messages. System messages (e.g. compaction
 * summaries) are pinned — dropping them would discard the most condensed
 * context first.
 */
declare function applySlidingWindow(messages: ChatTurn[], charCap: number, minKept: number): ChatTurn[];
/**
 * Keep an individual tool result under `byteCap`.
 *
 * If the payload carries a list of items (e.g. a `records.query` result), it is
 * degraded gracefully: as many leading items as fit under the cap are returned,
 * the `success: true` shape is preserved, and `{ truncated, returned, total }`
 * flags are merged in next to the array so callers can still use the partial
 * data and paginate for the rest.
 *
 * Only when there is no array to trim (or even an empty list still overflows
 * because of oversized sibling fields) does it fall back to replacing the
 * result with an error + small preview telling the agent to narrow its query.
 */
declare function capToolResultSize(result: unknown, byteCap: number): unknown;
/**
 * Convert persisted ChatTurns into AI SDK ModelMessages.
 *
 * Persisted assistant rows store `parts` in UI shape (text + tool-invocation,
 * each invocation carrying its own `result`). When fed back to the LLM, the
 * shape MUST match the original multi-step flow: an assistant message
 * containing a `tool_use` block must end with that block, the IMMEDIATELY
 * NEXT message must be a tool/user message containing the matching
 * `tool_result`, and any text the model produced AFTER seeing the tool
 * result belongs in a SEPARATE assistant message after the tool message.
 *
 * Anthropic specifically rejects an assistant message of the form
 * `[text, tool_use, text]` — the trailing text breaks its `tool_use` →
 * `tool_result` pairing check. So we walk the parts in order and split at
 * each tool-invocation boundary, emitting a fresh assistant + tool pair per
 * tool call, and a final trailing assistant message for any post-tool text.
 *
 * Tool-invocation entries with `state: 'call'` (no result — typically an
 * interrupted stream) are dropped on both sides.
 */
declare function turnsToCoreMessages(turns: ChatTurn[]): ModelMessage[];
/**
 * Convert AI SDK response messages into our persisted UI shape (text +
 * tool-invocation parts), pairing each assistant tool-call with its tool-
 * result from the following tool message. Order is chronological.
 *
 * Inverse of `turnsToCoreMessages`: takes the v5 `ModelMessage[]` returned
 * from `streamText`'s `onFinish` and produces the flat `parts` array we
 * persist on `ai-messages` rows. Reads `c.input` / `c.output` (v5 wire
 * names) and unwraps `output`'s tagged-union via `unwrapToolOutput`.
 */
declare function buildUiParts(responseMessages: ModelMessage[]): unknown[];
/**
 * Unwrap v5's tagged tool-result `output` to the flat shape we persist.
 * Errors get remapped to `{ success: false, error }` because
 * `truncateOldToolResults` preserves entries with that shape across turns —
 * without the remap, error context would get truncated like a normal result.
 */
declare function unwrapToolOutput(output: unknown): unknown;
/**
 * Pre-stream pipeline with compaction.
 *
 * 1. Truncate old tool results.
 * 2. If a cached summary covers a known message id, replace prior turns with it.
 * 3. If still over budget, summarize the older half of `working` and return a
 *    `newSummary` for persistence — runs even after cached-summary application
 *    so a long-running chat can re-summarize on subsequent turns.
 * 4. On summarizer error or missing ids, fall back to a sliding window
 *    (which preserves system messages — see `applySlidingWindow`).
 */
declare function prepareMessagesWithCompaction(messages: ChatTurn[], config: ChatContextConfig, options: {
    summarizer: Summarizer;
    cachedSummary?: {
        text: string;
        throughId: string;
    };
}): Promise<{
    messages: ChatTurn[];
    newSummary?: {
        text: string;
        throughId: string;
    };
}>;
/**
 * Build a default summarizer backed by Claude Haiku.
 *
 * Billing: defaults to the app owner via `APP_OWNER_JWT` — summarization is
 * usually infrastructure, not user work. Pass `{ authToken }` to bill a
 * specific user (e.g. the caller's JWT) instead.
 */
declare function makeDefaultSummarizer(env: DeepSpaceAIEnv, options?: {
    authToken?: string;
}): Summarizer;

/**
 * Chat history helpers — wrap RecordRoom's tools API for ai-chats / ai-messages.
 *
 * Trust model: every helper here runs through `executeToolAsApp`, which sends
 * `X-App-Action: 'true'` and therefore **bypasses RecordRoom's per-record
 * RBAC entirely**. The `userId` argument these helpers take is the identity
 * they act *as* — it is NOT an authorization boundary, and RecordRoom will
 * not check it. The worker is the only trust boundary.
 *
 * `getChat` is that boundary for this module: it compares the stored
 * `userId` against the caller and returns null on a mismatch, so the
 * worker's `/api/ai/chat`, `PATCH /api/ai/chats/:id`, and
 * `DELETE /api/ai/chats/:id` routes 404 when a row is missing *or* owned by
 * someone else. Every write helper (`updateChat`, `appendMessage`,
 * `deleteChatCascade`) is reachable only behind that precheck; a new caller
 * that skips it is writing across users, so route new consumers through
 * `getChat` first.
 *
 * `updateChat` and `appendMessage` re-run that precheck themselves and report
 * `false` instead of writing when the chat is gone: `records.update` /
 * `records.create` are upserts, so a write racing the user's delete would
 * resurrect the chat as a ghost row or orphan messages under a chat that no
 * longer exists. The guard lives in the helpers, not the routes, so every copy
 * of the scaffolded chat routes gets it.
 *
 * The tools API returns records as `{ recordId, data, createdAt, updatedAt }`
 * envelopes; helpers below flatten them into ChatRow / ChatMessageRow.
 */
type ChatRow = {
    recordId: string;
    userId: string;
    title: string;
    model?: string;
    compactedSummary?: string;
    compactedThroughId?: string;
    createdAt: string;
    updatedAt: string;
};
type ChatMessageRow = {
    recordId: string;
    chatId: string;
    userId: string;
    role: 'user' | 'assistant' | 'system';
    content: string;
    parts?: unknown[];
    createdAt: string;
};
/**
 * Fetch a chat the caller owns, or null.
 *
 * This is the module's authorization boundary. `records.get` runs with
 * `X-App-Action`, so RecordRoom applies no per-record RBAC and will happily
 * return another user's row — the ownership comparison below is the only
 * thing standing between a caller and someone else's chat. A miss and a
 * cross-user hit deliberately look identical to the caller (both null, both
 * 404 at the route) so chat ids stay unenumerable.
 */
declare function getChat(stub: DurableObjectStub, chatId: string, userId: string): Promise<ChatRow | null>;
declare function createChat(stub: DurableObjectStub, userId: string, opts?: {
    title?: string;
    model?: string;
}): Promise<ChatRow>;
/**
 * Patch a chat the caller owns. Returns true if the row was written, false if
 * the chat no longer exists (or never belonged to the caller).
 *
 * The `getChat` precheck is not redundant with the route's own: `records.update`
 * is an upsert on the DO — same code path as create — so an unguarded patch of
 * a chat the user deleted mid-stream *recreates* it as a title-less ghost whose
 * messages are already cascaded away. Writing only over a row that still exists
 * is the one place that can be prevented for every caller, so the guard lives
 * here rather than at each call site. A tiny TOCTOU window remains between the
 * read and the write (closing it needs a compare-and-set on the DO); a delete
 * landing inside that window is the same rare race as before, not the routine
 * "user deleted the chat while the stream ran" case this closes.
 */
declare function updateChat(stub: DurableObjectStub, chatId: string, userId: string, patch: Partial<Pick<ChatRow, 'title' | 'model' | 'compactedSummary' | 'compactedThroughId'>>): Promise<boolean>;
declare function deleteChatCascade(stub: DurableObjectStub, chatId: string, userId: string): Promise<void>;
declare function loadMessages(stub: DurableObjectStub, chatId: string, userId: string): Promise<ChatMessageRow[]>;
/**
 * Append one message to a chat the caller owns. Returns true if the row was
 * written, false if the chat is gone (or never belonged to the caller).
 *
 * Same write-after-delete guard as `updateChat`, for the same reason: a turn
 * that finishes after the user deleted the chat would otherwise write messages
 * whose parent row no longer exists — invisible in every listing and never
 * cascaded again.
 */
declare function appendMessage(stub: DurableObjectStub, msg: {
    id: string;
    chatId: string;
    userId: string;
    role: 'user' | 'assistant' | 'system';
    content: string;
    parts?: unknown[];
}): Promise<boolean>;

/**
 * Per-binding usage metering — record Vectorize / Workers AI / etc. costs
 * to the auto-attached `USAGE_EVENTS` Analytics Engine dataset.
 *
 * Why: the platform's tail-worker captures per-invocation compute (CPU + wall
 * time + script name) but it can't see which model an AI call hit, how many
 * tokens it embedded, or how many vectors a Vectorize query scanned. Without
 * those signals there's no way to surface per-tenant binding cost on the
 * billing dashboard.
 *
 * The deploy-worker auto-attaches a `USAGE_EVENTS` AE binding to every app
 * (dataset: `deepspace_binding_usage`). Apps don't need to declare it. They
 * just call `meterAi(...)` / `meterVectorize(...)` / `meterUsage(...)` after
 * each call and the dashboard rolls it up by `ownerUserId`.
 *
 * Schema written:
 *   indexes: [ownerUserId]
 *   blobs:   [appName, kind, model_or_index, op]
 *   doubles: [units, count]
 *
 * Use:
 *   await meterAi(env, '@cf/qwen/qwen3-embedding-0.6b', { inputChars: 5000 })
 *   await meterVectorize(env, 'unison-candidates', 'query', { vectors: 1000 })
 *   await meterUsage(env, 'custom-thing', { units: 1 })
 */
interface MeteringEnv {
    USAGE_EVENTS?: AnalyticsEngineDataset;
    OWNER_USER_ID?: string;
    DEEPSPACE_RESOURCE_ID?: string;
    APP_NAME?: string;
}
/**
 * Generic event recorder. Returns `false` if the binding isn't present
 * (dev / not yet deployed) or if AnalyticsEngine throws — metering must
 * never break the calling code path.
 */
declare function meterUsage(env: MeteringEnv, kind: string, fields?: {
    id?: string;
    op?: string;
    units?: number;
    count?: number;
}): boolean;
/**
 * Record a Workers AI call.
 *
 * Cloudflare prices input and output tokens at different rates for LLMs
 * (output is typically more expensive); embedding models bill input only.
 * Emits up to two events per call so the dashboard rollup can group by
 * `op` and apply the right per-token rate:
 *
 *   op='input'   units=inputChars
 *   op='output'  units=outputChars
 *
 * For a pure embedding call (outputChars=0), only the input event fires.
 * Pass `inputChars` and `outputChars` raw — the rough chars-to-token
 * conversion happens at price time using `COST_RATES.ai.embedInputPerChar`.
 *
 * Note: only embedding-input has an authoritative rate today. LLM-output
 * pricing varies wildly per model so `priceBindingUsageEvent` returns 0
 * for `op='output'` until per-model rates are wired. The events are still
 * recorded so the dashboard can show that the calls happened.
 */
declare function meterAi(env: MeteringEnv, model: string, fields?: {
    inputChars?: number;
    outputChars?: number;
    calls?: number;
}): boolean;
/**
 * Record a Vectorize operation.
 *
 * Cloudflare's published model (https://developers.cloudflare.com/vectorize/platform/pricing/):
 *
 *   "If you have 10,000 vectors with 384-dimensions in an index, and make
 *    100 queries against that index, your total queried vector dimensions
 *    would sum to 3.878 million ((10000 + 100) * 384)."
 *
 * So query billing is *additive* — `(stored + queries) * dims` summed
 * across the call, not per-query-multiplied-by-stored. Translating to a
 * per-call meter:
 *
 *   op='query':   units = (vectors + storedCount) * dims
 *                 Without `storedCount` we significantly undercount: a single
 *                 query against a 100K-vector index produces ~100K queried
 *                 dims, not just `dims`.
 *   op='upsert':  CF doesn't bill upserts directly; the chargeable delta is
 *                 the change to stored-vector-month. `units = vectors * dims`
 *                 approximates the per-call storage delta.
 *   op='delete' / 'getByIds':  recorded for observability; no direct cost.
 *
 * Edge case: querying an empty index gives `(1 + 0) * dims = dims`, which
 * matches CF's formula (the `+ queries` term is always added, even at 0
 * stored). If CF later changes that and an empty-index query bills 0,
 * adjust here — `metering` is the single place to update the math.
 */
declare function meterVectorize(env: MeteringEnv, indexName: string, op: 'query' | 'upsert' | 'delete' | 'getByIds', fields?: {
    vectors?: number;
    dims?: number;
    storedCount?: number;
}): boolean;
/**
 * Per-`units` USD multipliers, matched to the (`kind`, `op`) the meter
 * helpers above record. Dashboard rollup can multiply
 *
 *   SUM(_sample_interval * doubles[1])   -- units
 *
 * by these to surface $-figures without re-querying CF's billing API.
 */
declare const COST_RATES: {
    readonly ai: {
        /**
         * USD per character of *embedding input* (bge-m3 / qwen3-embedding tier).
         * Renamed from `perChar` to make explicit that this rate does NOT
         * apply to LLM-generation output — see `priceBindingUsageEvent`.
         */
        readonly embedInputPerChar: number;
    };
    readonly vectorize: {
        /** USD per queried dimension (per query, per stored vector compared). */
        readonly queriedPerDim: number;
        /** USD per stored dimension per month. */
        readonly storedPerDimPerMonth: number;
    };
    readonly aiSearch: {
        readonly ingestPerToken: number;
        readonly ingestImagePerToken: number;
        readonly storagePerByteMonth: number;
        readonly hybridOrSemanticPerQuery: number;
        readonly fulltextPerQuery: number;
    };
};
/**
 * Price a single rolled-up `deepspace_binding_usage` row. Lives next to
 * `COST_RATES` so the (kind, op) → rate mapping stays paired with the schema
 * the meter helpers write.
 *
 * Returns 0 for combinations without an authoritative per-unit rate; the row
 * still surfaces in dashboards for observability. Notable zeros:
 *   - `ai/output`: LLM-output prices vary per model and `meterAi` doesn't
 *     carry a model-family signal. Pricing it at the embedding rate would
 *     silently under-bill chat-LLM use.
 *   - `vectorize.storedPerDimPerMonth`: events are per-call deltas, not
 *     monthly snapshots, so a windowed SUM isn't meaningful here.
 */
declare function priceBindingUsageEvent(kind: string, op: string, units: number): number;

/**
 * App-identity headers for platform calls (api-worker, platform-worker).
 *
 * The pair is `x-app-identity-token` (HMAC(PLATFORM_IDENTITY_SECRET, appId),
 * minted at deploy time and injected as a binding) + `x-app-id`. Pre-first-
 * deploy the token binding is ABSENT — `deepspace dev start` can only fetch it once
 * the app is in the deploy registry. Attaching headers built from an undefined
 * binding sends the literal string "undefined", which upstream identity
 * verification rejects as a *tampered* token (401 invalid) instead of the
 * truthful "missing app identity" — so this helper fails closed by attaching
 * nothing when the token is unset. The starter's worker.ts proxies follow the
 * same policy (see reassertAppIdentity there).
 */
interface AppIdentityEnv {
    /** The app's immutable id (wrangler.toml [vars] DEEPSPACE_APP_ID). */
    DEEPSPACE_APP_ID: string;
    /** Absent until the app's first deploy injects it. */
    APP_IDENTITY_TOKEN?: string;
}

interface KnowledgeEnv extends ApiWorkerEnv, AppIdentityEnv {
}
type KnowledgeStatus = 'queued' | 'running' | 'completed' | 'error' | 'skipped' | 'outdated';
interface KnowledgeItem {
    id: string;
    key: string;
    status: KnowledgeStatus;
    fileSize?: number;
    chunksCount?: number;
    createdAt?: string;
    updatedAt?: string;
    error?: string;
}
interface KnowledgeAddOptions {
    folder?: string;
}
interface KnowledgeListOptions {
    folder?: string;
    page?: number;
    perPage?: number;
    status?: KnowledgeStatus;
    search?: string;
}
interface KnowledgeSearchOptions {
    folder?: string;
    mode?: 'hybrid' | 'semantic' | 'fulltext';
    limit?: number;
    matchThreshold?: number;
    queryRewrite?: boolean;
}
interface KnowledgeAddResult {
    items: KnowledgeItem[];
}
interface KnowledgeListResult {
    items: KnowledgeItem[];
    page: number;
    perPage: number;
    total?: number;
    totalPages?: number;
}
interface KnowledgeSearchChunk {
    id: string;
    score: number;
    text: string;
    key?: string;
    filename?: string;
    folder?: string;
    timestamp?: string;
}
interface KnowledgeSearchResult {
    chunks: KnowledgeSearchChunk[];
    queryKind?: string;
}
interface ScopedKnowledgeClient {
    add(file: File): Promise<KnowledgeAddResult>;
    list(options?: Omit<KnowledgeListOptions, 'folder'>): Promise<KnowledgeListResult>;
    search(query: string, options?: Omit<KnowledgeSearchOptions, 'folder'>): Promise<KnowledgeSearchResult>;
}
interface KnowledgeClient extends ScopedKnowledgeClient {
    add(file: File, options?: KnowledgeAddOptions): Promise<KnowledgeAddResult>;
    list(options?: KnowledgeListOptions): Promise<KnowledgeListResult>;
    remove(itemId: string): Promise<void>;
    search(query: string, options?: KnowledgeSearchOptions): Promise<KnowledgeSearchResult>;
    scoped(scope: {
        folder: string;
    }): ScopedKnowledgeClient;
}
declare class KnowledgeError extends Error {
    readonly status: number;
    readonly code: string;
    readonly uploadedItems?: KnowledgeItem[] | undefined;
    constructor(status: number, code: string, message: string, uploadedItems?: KnowledgeItem[] | undefined);
}
declare function normalizeKnowledgeFolder(folder: string): string;
declare function folderFilter(folder: string): {
    folder: {
        $gte: string;
        $lt: string;
    };
};
declare function knowledge(env: KnowledgeEnv): KnowledgeClient;

/**
 * Lightweight D1 schema bootstrapping for apps that use auto-provisioned
 * `[[d1_databases]]` bindings.
 *
 * The auto-provisioner gives apps an empty D1; the app needs to create its
 * own tables before using them. This helper runs ordered SQL fragments and
 * tracks which have applied via a `_dpc_migrations` meta-table so re-running
 * is a no-op:
 *
 * ```ts
 * import { runMigrations } from 'deepspace/worker'
 *
 * await runMigrations(env.CARDS_DB, [
 *   `CREATE TABLE cards (id INTEGER PRIMARY KEY, json TEXT NOT NULL);`,
 *   `CREATE INDEX idx_cards_updated ON cards(updated_at);`,
 * ])
 * ```
 *
 * **SQL formatting:** statements may span multiple lines freely. The runner
 * splits each migration string on `;` and runs each fragment via
 * `prepare().run()`. That sidesteps `db.exec()`'s newline-or-semicolon quirks
 * (it's optimized for migration files, not inline strings) and gets you
 * predictable single-statement semantics. Trailing `;` after the last
 * statement is fine; semicolons inside string literals are not (we use a
 * naive split, since DDL almost never has them).
 *
 * Each entry in the array is one migration. The runner records the index of
 * each successfully-applied migration in `_dpc_migrations`; subsequent calls
 * skip rows already recorded. Adding a new migration means appending to the
 * array; never reorder or delete entries.
 *
 * Why a meta-table instead of `PRAGMA user_version`: D1's SQLite authorizer
 * rejects PRAGMA writes with `SQLITE_AUTH`, even though the same statements
 * work in raw SQLite. A real table works on any D1 database and stays a
 * trivial bootstrap (one CREATE TABLE IF NOT EXISTS).
 *
 * Concurrency: D1 serializes statements per database, but two simultaneous
 * `runMigrations` callers could race the same migration index. The duplicate
 * INSERT collides on the primary key and the second caller sees the failure
 * — but the migration itself uses `IF NOT EXISTS` so the schema is correct
 * either way. Apps invoke this at startup which is single-threaded per
 * worker isolate; the cross-isolate race is rare and self-healing.
 *
 * This is the simplest possible migration story (option 1 in
 * docs/proposals/binding-auto-provisioning.md). Apps that outgrow it can
 * adopt CF's `wrangler d1 migrations apply` directly without breaking the
 * helper.
 */
interface RunMigrationsResult {
    /** Version before this run started. Equals the count of migrations already applied. */
    fromVersion: number;
    /** Version after migrations applied. Equals fromVersion if nothing ran. */
    toVersion: number;
    /** Number of migrations applied this call. */
    applied: number;
}
/**
 * Apply ordered SQL migrations to a D1 database. Idempotent: the next call
 * with the same array is a no-op until the array grows.
 *
 * Throws on any individual migration failure. The migrations meta-row is
 * only inserted after a migration succeeds, so a partial failure leaves a
 * recoverable state — fix the SQL, redeploy, and the failed migration runs
 * on next startup.
 */
declare function runMigrations(db: D1Database, migrations: readonly string[]): Promise<RunMigrationsResult>;

interface DocumentationAssistantRouteEnv extends DeepSpaceAIEnv {
    ASSETS: Fetcher;
    APP_NAME: string;
    DEEPSPACE_APP_ID: string;
    DOCUMENTATION_CLIENT_RATE_LIMITER?: RateLimit;
    DOCUMENTATION_APP_RATE_LIMITER?: RateLimit;
}

interface DocumentationMcpRouteEnv {
    ASSETS: Fetcher;
    DEEPSPACE_APP_ID: string;
    DOCUMENTATION_CLIENT_RATE_LIMITER?: RateLimit;
    DOCUMENTATION_APP_RATE_LIMITER?: RateLimit;
}

interface DeepSpaceDocumentationRouteEnv extends DocumentationAssistantRouteEnv, DocumentationMcpRouteEnv {
}
interface DeepSpaceDocumentationRouteOptions<Env extends DeepSpaceDocumentationRouteEnv> {
    resolveAuth: (request: Request, env: Env) => Promise<unknown | null>;
    config?: {
        domains?: readonly string[];
        [key: string]: unknown;
    };
}
/** Register the complete native documentation protocol surface in its required order. */
declare function registerDeepSpaceDocumentation<Env extends DeepSpaceDocumentationRouteEnv>(app: Hono<{
    Bindings: Env;
}>, options: DeepSpaceDocumentationRouteOptions<Env>): void;

/**
 * Auth types for the DeepSpace SDK.
 *
 * Provider-agnostic shapes for JWT verification (issuer, audience, azp
 * matching, ES256 public key) and the HMAC-signed internal-request
 * envelope used for worker-to-worker calls.
 */
interface JwtVerifierConfig {
    /** PEM-encoded public key (ES256) for JWT verification */
    publicKey: string;
    /** Expected issuer (e.g. "https://auth.deep.space/api/auth") */
    issuer: string;
    /** Expected audience (usually the configured platform API URL) */
    audience?: string | string[];
    /** Allowed origins / authorized parties (supports wildcards like "https://*.app.space") */
    authorizedParties?: string[];
    /** Clock skew tolerance in milliseconds (default: 5000) */
    clockSkewMs?: number;
}
interface JwtClaims {
    sub: string;
    iss?: string;
    aud?: string | string[];
    azp?: string;
    exp?: number;
    iat?: number;
    name?: string;
    email?: string;
    image?: string;
    [key: string]: unknown;
}
interface VerifiedAuth {
    userId: string;
    claims: JwtClaims;
}
type VerifyResult = VerifiedAuth;
interface TokenDebugInfo {
    iss?: string | null;
    aud?: string | string[] | null;
    azp?: string | null;
    exp?: number | null;
    iat?: number | null;
}
interface VerifyOutcome {
    result: VerifyResult | null;
    debug?: TokenDebugInfo;
    error?: unknown;
}

/**
 * JWT verification for DeepSpace workers.
 *
 * jose-based ES256 verification (jose runs on the Cloudflare Workers
 * edge runtime). Imported public keys are cached per-PEM to avoid
 * re-importing on every request, and `azp` is matched against an
 * optional list of authorized-party patterns supporting `*` wildcards.
 */

/**
 * Verify a DeepSpace JWT token.
 *
 * @param config - Verification configuration (public key, issuer, audience)
 * @param token - The JWT string to verify
 * @returns VerifyOutcome with either the verified result or error details
 */
declare function verifyJwt(config: JwtVerifierConfig, token: string | null | undefined): Promise<VerifyOutcome>;

/**
 * Session-cookie identity for header-less file reads.
 *
 * `<img>`, `<audio>`, `<video>`, and `<a href>` cannot send `Authorization`,
 * but the browser attaches the app-origin Better Auth session cookie to every
 * same-origin load. This exchanges that cookie for the same 15-minute JWT the
 * client already holds and returns only the verified identity.
 *
 * Bearer always wins: this applies only when no `Authorization` header is
 * present, only to GET/HEAD, and only when `Sec-Fetch-Site` is `same-origin`
 * or `none`. `app.space` is not on the Public Suffix List, so a sibling
 * `evil.app.space` is same-SITE and `SameSite=Lax` alone would let its
 * `<img src>` carry the victim's cookie; `Sec-Fetch-Site` cannot be set by
 * page script. A browser that omits it (Safari before 16.4) and a cross-site
 * top-level link both get 401 by design.
 */

type SessionReadEnv = AuthWorkerEnv & {
    AUTH_JWT_PUBLIC_KEY: string;
    AUTH_JWT_ISSUER: string;
};
/**
 * Identify a same-origin GET/HEAD by the app-origin session cookie. Returns
 * `null` — never throws — whenever the request does not qualify or the
 * exchange fails. Use it only as the fallback after bearer verification.
 */
declare function resolveSessionReadAuth(req: Request, env: SessionReadEnv): Promise<VerifyResult | null>;

declare const AGENT_TOKEN_SCOPE = "agent";
/** A separate issuer keeps agent credentials invalid at ordinary platform APIs. */
declare function agentTokenIssuer(issuer: string): string;
/** Verify an agent credential for the exact origin currently receiving it. */
declare function verifyAgentToken(config: Omit<JwtVerifierConfig, 'audience'>, token: string | null | undefined, targetOrigin: string): Promise<VerifyOutcome>;

/**
 * HMAC primitives used by the per-app identity tokens (APP_IDENTITY_TOKEN)
 * minted at deploy time and verified on every /internal/* call into the
 * platform worker. Auth-provider-agnostic.
 */
declare function computeHmacHex(secret: string, payload: string): Promise<string>;
declare function timingSafeEqualHex(a: string, b: string): Promise<boolean>;
/**
 * Constant-time equality for arbitrary strings (hash-then-compare: SHA-256
 * normalizes lengths so neither length nor content short-circuits). The one
 * implementation every worker's bearer/secret checks share.
 */
declare function timingSafeEqualStrings(a: string, b: string): Promise<boolean>;

declare function decodeJwtPayload(token: string | null | undefined): TokenDebugInfo | undefined;

/**
 * Test-account identification, shared by every platform worker.
 *
 * Test accounts (created via `deepspace test accounts`) are real Better Auth
 * users demarcated three ways, and a caller may present as any of them
 * depending on where the check runs:
 *  - their email always ends with @deepspace.test (enforced at creation)
 *  - their JWTs carry `isTestAccount: true` (minted by the auth-worker,
 *    the source of truth)
 *  - their billing profile's subscription tier is 'test' (mirrored by the
 *    api-worker on every authenticated request)
 *
 * Gate anything a test account must not do with these helpers rather than
 * hand-rolled string comparisons, so the policy stays in one place. Prefer
 * checking the claim when a verified JWT is at hand, and the tier as the
 * fallback for persisted state that may outlive a claim (e.g. rows written
 * before a guard existed).
 */

declare const TEST_ACCOUNT_EMAIL_SUFFIX = "@deepspace.test";
/** True when the email belongs to a test account (case-insensitive). */
declare function isTestAccountEmail(email: string | null | undefined): boolean;
/** True when verified JWT claims identify the caller as a test account. */
declare function isTestAccountClaims(claims: JwtClaims | Record<string, unknown> | null | undefined): boolean;
/** True when a billing subscription tier marks a test account. */
declare function isTestAccountTier(tier: string | null | undefined): boolean;

interface DeepSpaceAuthConfig {
    /** D1 database binding */
    database: D1Database;
    /** Base URL for the auth worker (e.g. "https://auth.deep.space") */
    baseURL: string;
    /** Secret for session signing */
    secret: string;
    /** Google OAuth credentials (optional) */
    google?: {
        clientId: string;
        clientSecret: string;
    };
    /** GitHub OAuth credentials (optional) */
    github?: {
        clientId: string;
        clientSecret: string;
    };
    /** Microsoft (Entra ID) OAuth credentials (optional) */
    microsoft?: {
        clientId: string;
        clientSecret: string;
    };
    /**
     * Apple (Sign in with Apple) credentials (optional). Pass the raw
     * Sign-in-with-Apple key material; the ES256 client-secret JWT is minted
     * on demand, so there is no six-month token to rotate by hand.
     */
    apple?: {
        clientId: string;
        teamId: string;
        keyId: string;
        privateKey: string;
    };
    /** Enable email/password authentication */
    emailAndPassword?: boolean;
    /** Trusted origins for CORS */
    trustedOrigins?: string[];
    /**
     * Called after a new user row is created (any flow: social OAuth callback,
     * email/password, server-side `auth.api.signUpEmail`). When the signup came
     * in over HTTP, `ctx.request` exposes the inbound request; some better-auth
     * entry points carry standalone `ctx.headers` instead of (or as well as) a
     * request, so both are forwarded. For server-side creations (`auth.api.*`
     * calls) an endpoint context usually still exists but may carry NEITHER —
     * guard every field.
     *
     * Better Auth awaits `user.create.after` hooks inline before the response
     * is sent, so keep this cheap (e.g. a single D1 write) and hand slow work
     * to `ctx.waitUntil` at the call site. Exceptions are caught and logged so
     * a failing observer can never break signup itself.
     */
    onUserCreated?: (user: {
        id: string;
        email: string;
        name: string;
    }, ctx: {
        request?: Request;
        headers?: Headers;
    } | null) => Promise<void>;
}
declare function createDeepSpaceAuth(config: DeepSpaceAuthConfig): better_auth.Auth<{
    databaseHooks: {
        user?: {
            create?: {
                before?: (user: better_auth.User & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void | {
                    data: {
                        id?: string | undefined;
                        createdAt?: Date | undefined;
                        updatedAt?: Date | undefined;
                        email?: string | undefined;
                        emailVerified?: boolean | undefined;
                        name?: string | undefined;
                        image?: string | null | undefined;
                    } & Record<string, any>;
                }>;
                after?: (user: better_auth.User & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
            update?: {
                before?: (user: Partial<better_auth.User> & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void | {
                    data: {
                        [x: string]: any;
                        id?: string | undefined;
                        createdAt?: Date | undefined;
                        updatedAt?: Date | undefined;
                        email?: string | undefined;
                        emailVerified?: boolean | undefined;
                        name?: string | undefined;
                        image?: string | null | undefined;
                    };
                }>;
                after?: (user: better_auth.User & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
            delete?: {
                before?: (user: better_auth.User & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void>;
                after?: (user: better_auth.User & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
        };
        session?: {
            create?: {
                before?: (session: better_auth.Session & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void | {
                    data: {
                        id?: string | undefined;
                        createdAt?: Date | undefined;
                        updatedAt?: Date | undefined;
                        userId?: string | undefined;
                        expiresAt?: Date | undefined;
                        token?: string | undefined;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    } & Record<string, any>;
                }>;
                after?: (session: better_auth.Session & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
            update?: {
                before?: (session: Partial<better_auth.Session> & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void | {
                    data: {
                        [x: string]: any;
                        id?: string | undefined;
                        createdAt?: Date | undefined;
                        updatedAt?: Date | undefined;
                        userId?: string | undefined;
                        expiresAt?: Date | undefined;
                        token?: string | undefined;
                        ipAddress?: string | null | undefined;
                        userAgent?: string | null | undefined;
                    };
                }>;
                after?: (session: better_auth.Session & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
            delete?: {
                before?: (session: better_auth.Session & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void>;
                after?: (session: better_auth.Session & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
        };
        account?: {
            create?: {
                before?: (account: better_auth.Account, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void | {
                    data: {
                        id?: string | undefined;
                        createdAt?: Date | undefined;
                        updatedAt?: Date | undefined;
                        providerId?: string | undefined;
                        accountId?: string | undefined;
                        userId?: string | undefined;
                        accessToken?: string | null | undefined;
                        refreshToken?: string | null | undefined;
                        idToken?: string | null | undefined;
                        accessTokenExpiresAt?: Date | null | undefined;
                        refreshTokenExpiresAt?: Date | null | undefined;
                        scope?: string | null | undefined;
                        password?: string | null | undefined;
                    } & Record<string, any>;
                }>;
                after?: (account: better_auth.Account, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
            update?: {
                before?: (account: Partial<better_auth.Account> & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void | {
                    data: {
                        [x: string]: any;
                        id?: string | undefined;
                        createdAt?: Date | undefined;
                        updatedAt?: Date | undefined;
                        providerId?: string | undefined;
                        accountId?: string | undefined;
                        userId?: string | undefined;
                        accessToken?: string | null | undefined;
                        refreshToken?: string | null | undefined;
                        idToken?: string | null | undefined;
                        accessTokenExpiresAt?: Date | null | undefined;
                        refreshTokenExpiresAt?: Date | null | undefined;
                        scope?: string | null | undefined;
                        password?: string | null | undefined;
                    };
                }>;
                after?: (account: better_auth.Account & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
            delete?: {
                before?: (account: better_auth.Account & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void>;
                after?: (account: better_auth.Account & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
        };
        verification?: {
            create?: {
                before?: (verification: better_auth.Verification & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void | {
                    data: {
                        id?: string | undefined;
                        createdAt?: Date | undefined;
                        updatedAt?: Date | undefined;
                        value?: string | undefined;
                        expiresAt?: Date | undefined;
                        identifier?: string | undefined;
                    } & Record<string, any>;
                }>;
                after?: (verification: better_auth.Verification & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
            update?: {
                before?: (verification: Partial<better_auth.Verification> & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void | {
                    data: {
                        [x: string]: any;
                        id?: string | undefined;
                        createdAt?: Date | undefined;
                        updatedAt?: Date | undefined;
                        value?: string | undefined;
                        expiresAt?: Date | undefined;
                        identifier?: string | undefined;
                    };
                }>;
                after?: (verification: better_auth.Verification & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
            delete?: {
                before?: (verification: better_auth.Verification & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<boolean | void>;
                after?: (verification: better_auth.Verification & Record<string, unknown>, context: better_auth.GenericEndpointContext | null) => Promise<void>;
            };
        };
    } | undefined;
    plugins: [{
        id: "organization";
        version: string;
        endpoints: better_auth_plugins.OrganizationEndpoints<better_auth_plugins.OrganizationOptions & {
            teams: {
                enabled: true;
            };
            dynamicAccessControl?: {
                enabled?: false | undefined;
            } | undefined;
        }> & better_auth_plugins.TeamEndpoints<better_auth_plugins.OrganizationOptions & {
            teams: {
                enabled: true;
            };
            dynamicAccessControl?: {
                enabled?: false | undefined;
            } | undefined;
        }>;
        schema: better_auth_plugins.OrganizationSchema<better_auth_plugins.OrganizationOptions & {
            teams: {
                enabled: true;
            };
            dynamicAccessControl?: {
                enabled?: false | undefined;
            } | undefined;
        }>;
        $Infer: {
            Organization: {
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            };
            Invitation: {
                id: string;
                organizationId: string;
                email: string;
                role: "member" | "admin" | "owner";
                status: better_auth_plugins.InvitationStatus;
                inviterId: string;
                expiresAt: Date;
                createdAt: Date;
                teamId?: string | undefined | undefined;
            };
            Member: {
                id: string;
                organizationId: string;
                role: "member" | "admin" | "owner";
                createdAt: Date;
                userId: string;
                teamId?: string | undefined | undefined;
                user: {
                    id: string;
                    email: string;
                    name: string;
                    image?: string | undefined;
                };
            };
            Team: {
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt?: Date | undefined;
            };
            TeamMember: {
                id: string;
                teamId: string;
                userId: string;
                createdAt: Date;
            };
            ActiveOrganization: {
                members: {
                    id: string;
                    organizationId: string;
                    role: "member" | "admin" | "owner";
                    createdAt: Date;
                    userId: string;
                    teamId?: string | undefined | undefined;
                    user: {
                        id: string;
                        email: string;
                        name: string;
                        image?: string | undefined;
                    };
                }[];
                invitations: {
                    id: string;
                    organizationId: string;
                    email: string;
                    role: "member" | "admin" | "owner";
                    status: better_auth_plugins.InvitationStatus;
                    inviterId: string;
                    expiresAt: Date;
                    createdAt: Date;
                    teamId?: string | undefined | undefined;
                }[];
                teams: {
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt?: Date | undefined;
                }[];
            } & {
                id: string;
                name: string;
                slug: string;
                createdAt: Date;
                logo?: string | null | undefined;
                metadata?: any;
            };
        };
        $ERROR_CODES: {
            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_ORGANIZATION">;
            YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS: better_auth.RawError<"YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_ORGANIZATIONS">;
            ORGANIZATION_ALREADY_EXISTS: better_auth.RawError<"ORGANIZATION_ALREADY_EXISTS">;
            ORGANIZATION_SLUG_ALREADY_TAKEN: better_auth.RawError<"ORGANIZATION_SLUG_ALREADY_TAKEN">;
            ORGANIZATION_NOT_FOUND: better_auth.RawError<"ORGANIZATION_NOT_FOUND">;
            USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION: better_auth.RawError<"USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION">;
            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_ORGANIZATION">;
            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_ORGANIZATION">;
            NO_ACTIVE_ORGANIZATION: better_auth.RawError<"NO_ACTIVE_ORGANIZATION">;
            USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION: better_auth.RawError<"USER_IS_ALREADY_A_MEMBER_OF_THIS_ORGANIZATION">;
            MEMBER_NOT_FOUND: better_auth.RawError<"MEMBER_NOT_FOUND">;
            ROLE_NOT_FOUND: better_auth.RawError<"ROLE_NOT_FOUND">;
            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM">;
            TEAM_ALREADY_EXISTS: better_auth.RawError<"TEAM_ALREADY_EXISTS">;
            TEAM_NOT_FOUND: better_auth.RawError<"TEAM_NOT_FOUND">;
            YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER: better_auth.RawError<"YOU_CANNOT_LEAVE_THE_ORGANIZATION_AS_THE_ONLY_OWNER">;
            YOU_CANNOT_LEAVE_THE_ORGANIZATION_WITHOUT_AN_OWNER: better_auth.RawError<"YOU_CANNOT_LEAVE_THE_ORGANIZATION_WITHOUT_AN_OWNER">;
            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_MEMBER">;
            YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION">;
            USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION: better_auth.RawError<"USER_IS_ALREADY_INVITED_TO_THIS_ORGANIZATION">;
            INVITATION_NOT_FOUND: better_auth.RawError<"INVITATION_NOT_FOUND">;
            YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION: better_auth.RawError<"YOU_ARE_NOT_THE_RECIPIENT_OF_THE_INVITATION">;
            EMAIL_VERIFICATION_REQUIRED_BEFORE_ACCEPTING_OR_REJECTING_INVITATION: better_auth.RawError<"EMAIL_VERIFICATION_REQUIRED_BEFORE_ACCEPTING_OR_REJECTING_INVITATION">;
            EMAIL_VERIFICATION_REQUIRED_FOR_INVITATION: better_auth.RawError<"EMAIL_VERIFICATION_REQUIRED_FOR_INVITATION">;
            YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CANCEL_THIS_INVITATION">;
            INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION: better_auth.RawError<"INVITER_IS_NO_LONGER_A_MEMBER_OF_THE_ORGANIZATION">;
            YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_INVITE_USER_WITH_THIS_ROLE">;
            FAILED_TO_RETRIEVE_INVITATION: better_auth.RawError<"FAILED_TO_RETRIEVE_INVITATION">;
            YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS: better_auth.RawError<"YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS">;
            UNABLE_TO_REMOVE_LAST_TEAM: better_auth.RawError<"UNABLE_TO_REMOVE_LAST_TEAM">;
            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER">;
            ORGANIZATION_MEMBERSHIP_LIMIT_REACHED: better_auth.RawError<"ORGANIZATION_MEMBERSHIP_LIMIT_REACHED">;
            YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION">;
            YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION">;
            YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM">;
            YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM">;
            INVITATION_LIMIT_REACHED: better_auth.RawError<"INVITATION_LIMIT_REACHED">;
            TEAM_MEMBER_LIMIT_REACHED: better_auth.RawError<"TEAM_MEMBER_LIMIT_REACHED">;
            USER_IS_NOT_A_MEMBER_OF_THE_TEAM: better_auth.RawError<"USER_IS_NOT_A_MEMBER_OF_THE_TEAM">;
            YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM: better_auth.RawError<"YOU_CAN_NOT_ACCESS_THE_MEMBERS_OF_THIS_TEAM">;
            YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM: better_auth.RawError<"YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM">;
            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER">;
            YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER">;
            YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION">;
            YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION: better_auth.RawError<"YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION">;
            MISSING_AC_INSTANCE: better_auth.RawError<"MISSING_AC_INSTANCE">;
            YOU_MUST_BE_IN_AN_ORGANIZATION_TO_CREATE_A_ROLE: better_auth.RawError<"YOU_MUST_BE_IN_AN_ORGANIZATION_TO_CREATE_A_ROLE">;
            YOU_ARE_NOT_ALLOWED_TO_CREATE_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_A_ROLE">;
            YOU_ARE_NOT_ALLOWED_TO_UPDATE_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_A_ROLE">;
            YOU_ARE_NOT_ALLOWED_TO_DELETE_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_A_ROLE">;
            YOU_ARE_NOT_ALLOWED_TO_READ_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_READ_A_ROLE">;
            YOU_ARE_NOT_ALLOWED_TO_LIST_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_A_ROLE">;
            YOU_ARE_NOT_ALLOWED_TO_GET_A_ROLE: better_auth.RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_A_ROLE">;
            TOO_MANY_ROLES: better_auth.RawError<"TOO_MANY_ROLES">;
            INVALID_RESOURCE: better_auth.RawError<"INVALID_RESOURCE">;
            ROLE_NAME_IS_ALREADY_TAKEN: better_auth.RawError<"ROLE_NAME_IS_ALREADY_TAKEN">;
            CANNOT_DELETE_A_PRE_DEFINED_ROLE: better_auth.RawError<"CANNOT_DELETE_A_PRE_DEFINED_ROLE">;
            ROLE_IS_ASSIGNED_TO_MEMBERS: better_auth.RawError<"ROLE_IS_ASSIGNED_TO_MEMBERS">;
            INVALID_TEAM_ID: better_auth.RawError<"INVALID_TEAM_ID">;
        };
        options: NoInfer<better_auth_plugins.OrganizationOptions & {
            teams: {
                enabled: true;
            };
            dynamicAccessControl?: {
                enabled?: false | undefined;
            } | undefined;
        }>;
    }, {
        id: "two-factor";
        version: string;
        endpoints: {
            enableTwoFactor: better_auth.StrictEndpoint<"/two-factor/enable", {
                method: "POST";
                body: zod.ZodObject<{
                    password: zod.ZodOptional<zod.ZodString>;
                    issuer: zod.ZodOptional<zod.ZodString>;
                }, zod_v4_core.$strip> | zod.ZodObject<{
                    password: zod.ZodString;
                    issuer: zod.ZodOptional<zod.ZodString>;
                }, zod_v4_core.$strip>;
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            email: string;
                            emailVerified: boolean;
                            name: string;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
                metadata: {
                    openapi: {
                        summary: string;
                        description: string;
                        responses: {
                            200: {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                totpURI: {
                                                    type: string;
                                                    description: string;
                                                };
                                                backupCodes: {
                                                    type: string;
                                                    items: {
                                                        type: string;
                                                    };
                                                    description: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                totpURI: string;
                backupCodes: string[];
            }>;
            disableTwoFactor: better_auth.StrictEndpoint<"/two-factor/disable", {
                method: "POST";
                body: zod.ZodObject<{
                    password: zod.ZodOptional<zod.ZodString>;
                }, zod_v4_core.$strip> | zod.ZodObject<{
                    password: zod.ZodString;
                }, zod_v4_core.$strip>;
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            email: string;
                            emailVerified: boolean;
                            name: string;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
                metadata: {
                    openapi: {
                        summary: string;
                        description: string;
                        responses: {
                            200: {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                status: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                status: boolean;
            }>;
            verifyBackupCode: better_auth.StrictEndpoint<"/two-factor/verify-backup-code", {
                method: "POST";
                body: zod.ZodObject<{
                    code: zod.ZodString;
                    disableSession: zod.ZodOptional<zod.ZodBoolean>;
                    trustDevice: zod.ZodOptional<zod.ZodBoolean>;
                }, zod_v4_core.$strip>;
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                user: {
                                                    type: string;
                                                    properties: {
                                                        id: {
                                                            type: string;
                                                            description: string;
                                                        };
                                                        email: {
                                                            type: string;
                                                            format: string;
                                                            nullable: boolean;
                                                            description: string;
                                                        };
                                                        emailVerified: {
                                                            type: string;
                                                            nullable: boolean;
                                                            description: string;
                                                        };
                                                        name: {
                                                            type: string;
                                                            nullable: boolean;
                                                            description: string;
                                                        };
                                                        image: {
                                                            type: string;
                                                            format: string;
                                                            nullable: boolean;
                                                            description: string;
                                                        };
                                                        twoFactorEnabled: {
                                                            type: string;
                                                            description: string;
                                                        };
                                                        createdAt: {
                                                            type: string;
                                                            format: string;
                                                            description: string;
                                                        };
                                                        updatedAt: {
                                                            type: string;
                                                            format: string;
                                                            description: string;
                                                        };
                                                    };
                                                    required: string[];
                                                    description: string;
                                                };
                                                session: {
                                                    type: string;
                                                    properties: {
                                                        token: {
                                                            type: string;
                                                            description: string;
                                                        };
                                                        userId: {
                                                            type: string;
                                                            description: string;
                                                        };
                                                        createdAt: {
                                                            type: string;
                                                            format: string;
                                                            description: string;
                                                        };
                                                        expiresAt: {
                                                            type: string;
                                                            format: string;
                                                            description: string;
                                                        };
                                                    };
                                                    required: string[];
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                token: string | undefined;
                user: (Record<string, any> & {
                    id: string;
                    createdAt: Date;
                    updatedAt: Date;
                    email: string;
                    emailVerified: boolean;
                    name: string;
                    image?: string | null | undefined;
                }) | better_auth_plugins.UserWithTwoFactor;
            }>;
            generateBackupCodes: better_auth.StrictEndpoint<"/two-factor/generate-backup-codes", {
                method: "POST";
                body: zod.ZodObject<{
                    password: zod.ZodOptional<zod.ZodString>;
                }, zod_v4_core.$strip> | zod.ZodObject<{
                    password: zod.ZodString;
                }, zod_v4_core.$strip>;
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            email: string;
                            emailVerified: boolean;
                            name: string;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
                metadata: {
                    openapi: {
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                status: {
                                                    type: string;
                                                    description: string;
                                                    enum: boolean[];
                                                };
                                                backupCodes: {
                                                    type: string;
                                                    items: {
                                                        type: string;
                                                    };
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                status: boolean;
                backupCodes: string[];
            }>;
            viewBackupCodes: better_auth.StrictEndpoint<string, {
                method: "POST";
                body: zod.ZodObject<{
                    userId: zod.ZodCoercedString<unknown>;
                }, zod_v4_core.$strip>;
            }, {
                status: boolean;
                backupCodes: string[];
            }>;
            sendTwoFactorOTP: better_auth.StrictEndpoint<"/two-factor/send-otp", {
                method: "POST";
                body: zod.ZodOptional<zod.ZodObject<{
                    trustDevice: zod.ZodOptional<zod.ZodBoolean>;
                }, zod_v4_core.$strip>>;
                metadata: {
                    openapi: {
                        summary: string;
                        description: string;
                        responses: {
                            200: {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                status: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                status: boolean;
            }>;
            verifyTwoFactorOTP: better_auth.StrictEndpoint<"/two-factor/verify-otp", {
                method: "POST";
                body: zod.ZodObject<{
                    code: zod.ZodString;
                    trustDevice: zod.ZodOptional<zod.ZodBoolean>;
                }, zod_v4_core.$strip>;
                metadata: {
                    openapi: {
                        summary: string;
                        description: string;
                        responses: {
                            "200": {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                token: {
                                                    type: string;
                                                    description: string;
                                                };
                                                user: {
                                                    type: string;
                                                    properties: {
                                                        id: {
                                                            type: string;
                                                            description: string;
                                                        };
                                                        email: {
                                                            type: string;
                                                            format: string;
                                                            nullable: boolean;
                                                            description: string;
                                                        };
                                                        emailVerified: {
                                                            type: string;
                                                            nullable: boolean;
                                                            description: string;
                                                        };
                                                        name: {
                                                            type: string;
                                                            nullable: boolean;
                                                            description: string;
                                                        };
                                                        image: {
                                                            type: string;
                                                            format: string;
                                                            nullable: boolean;
                                                            description: string;
                                                        };
                                                        createdAt: {
                                                            type: string;
                                                            format: string;
                                                            description: string;
                                                        };
                                                        updatedAt: {
                                                            type: string;
                                                            format: string;
                                                            description: string;
                                                        };
                                                    };
                                                    required: string[];
                                                    description: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                token: string;
                user: better_auth_plugins.UserWithTwoFactor;
            } | {
                token: string;
                user: Record<string, any> & {
                    id: string;
                    createdAt: Date;
                    updatedAt: Date;
                    email: string;
                    emailVerified: boolean;
                    name: string;
                    image?: string | null | undefined;
                };
            }>;
            generateTOTP: better_auth.StrictEndpoint<string, {
                method: "POST";
                body: zod.ZodObject<{
                    secret: zod.ZodString;
                }, zod_v4_core.$strip>;
                metadata: {
                    openapi: {
                        summary: string;
                        description: string;
                        responses: {
                            200: {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                code: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                code: string;
            }>;
            getTOTPURI: better_auth.StrictEndpoint<"/two-factor/get-totp-uri", {
                method: "POST";
                use: ((inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    session: {
                        session: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            userId: string;
                            expiresAt: Date;
                            token: string;
                            ipAddress?: string | null | undefined;
                            userAgent?: string | null | undefined;
                        };
                        user: Record<string, any> & {
                            id: string;
                            createdAt: Date;
                            updatedAt: Date;
                            email: string;
                            emailVerified: boolean;
                            name: string;
                            image?: string | null | undefined;
                        };
                    };
                }>)[];
                body: zod.ZodObject<{
                    password: zod.ZodOptional<zod.ZodString>;
                }, zod_v4_core.$strip> | zod.ZodObject<{
                    password: zod.ZodString;
                }, zod_v4_core.$strip>;
                metadata: {
                    openapi: {
                        summary: string;
                        description: string;
                        responses: {
                            200: {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                totpURI: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                totpURI: string;
            }>;
            verifyTOTP: better_auth.StrictEndpoint<"/two-factor/verify-totp", {
                method: "POST";
                body: zod.ZodObject<{
                    code: zod.ZodString;
                    trustDevice: zod.ZodOptional<zod.ZodBoolean>;
                }, zod_v4_core.$strip>;
                metadata: {
                    openapi: {
                        summary: string;
                        description: string;
                        responses: {
                            200: {
                                description: string;
                                content: {
                                    "application/json": {
                                        schema: {
                                            type: "object";
                                            properties: {
                                                status: {
                                                    type: string;
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }, {
                token: string;
                user: better_auth_plugins.UserWithTwoFactor;
            } | {
                token: string;
                user: Record<string, any> & {
                    id: string;
                    createdAt: Date;
                    updatedAt: Date;
                    email: string;
                    emailVerified: boolean;
                    name: string;
                    image?: string | null | undefined;
                };
            }>;
        };
        options: NoInfer<better_auth_plugins.TwoFactorOptions>;
        hooks: {
            after: {
                matcher(context: better_auth.HookEndpointContext): boolean;
                handler: (inputContext: better_auth.MiddlewareInputContext<better_auth.MiddlewareOptions>) => Promise<{
                    twoFactorRedirect: boolean;
                    twoFactorMethods: string[];
                } | undefined>;
            }[];
        };
        schema: {
            user: {
                fields: {
                    twoFactorEnabled: {
                        type: "boolean";
                        required: false;
                        defaultValue: false;
                        input: false;
                    };
                };
            };
            twoFactor: {
                fields: {
                    secret: {
                        type: "string";
                        required: true;
                        returned: false;
                        index: true;
                    };
                    backupCodes: {
                        type: "string";
                        required: true;
                        returned: false;
                    };
                    userId: {
                        type: "string";
                        required: true;
                        returned: false;
                        references: {
                            model: string;
                            field: string;
                        };
                        index: true;
                    };
                    verified: {
                        type: "boolean";
                        required: false;
                        defaultValue: true;
                        input: false;
                    };
                    failedVerificationCount: {
                        type: "number";
                        required: false;
                        defaultValue: number;
                        input: false;
                        returned: false;
                    };
                    lockedUntil: {
                        type: "date";
                        required: false;
                        input: false;
                        returned: false;
                    };
                };
            };
        };
        rateLimit: {
            pathMatcher(path: string): boolean;
            window: number;
            max: number;
        }[];
        $ERROR_CODES: {
            OTP_NOT_ENABLED: better_auth.RawError<"OTP_NOT_ENABLED">;
            OTP_HAS_EXPIRED: better_auth.RawError<"OTP_HAS_EXPIRED">;
            TOTP_NOT_ENABLED: better_auth.RawError<"TOTP_NOT_ENABLED">;
            TWO_FACTOR_NOT_ENABLED: better_auth.RawError<"TWO_FACTOR_NOT_ENABLED">;
            BACKUP_CODES_NOT_ENABLED: better_auth.RawError<"BACKUP_CODES_NOT_ENABLED">;
            INVALID_BACKUP_CODE: better_auth.RawError<"INVALID_BACKUP_CODE">;
            INVALID_CODE: better_auth.RawError<"INVALID_CODE">;
            TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: better_auth.RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
            ACCOUNT_TEMPORARILY_LOCKED: better_auth.RawError<"ACCOUNT_TEMPORARILY_LOCKED">;
            INVALID_TWO_FACTOR_COOKIE: better_auth.RawError<"INVALID_TWO_FACTOR_COOKIE">;
        };
    }];
    advanced?: {
        cookies: {
            state: {
                attributes: {
                    sameSite: "none";
                    secure: true;
                };
            };
            oauth_state: {
                attributes: {
                    sameSite: "none";
                    secure: true;
                };
            };
        };
    } | undefined;
    database: D1Database;
    baseURL: string;
    secret: string;
    session: {
        expiresIn: number;
        updateAge: number;
    };
    emailAndPassword: {
        enabled: boolean;
    };
    socialProviders: Parameters<typeof betterAuth>[0]["socialProviders"];
    trustedOrigins: string[];
}>;
type DeepSpaceAuth = ReturnType<typeof createDeepSpaceAuth>;

/**
 * Yjs collaborative editing handlers for RecordRoom
 */

/** Collections that bypass schema checks (permissive access) */
declare const SYSTEM_COLLECTIONS: Set<string>;

/** Wire-size limits shared by the app Worker and the stateless CLI bridge. */
/** Maximum JSON body accepted by one tool invocation. */
declare const AGENT_TOOL_REQUEST_BODY_CAP: number;
/** Maximum JSON response accepted or emitted by the discovery bridge. */
declare const AGENT_TOOL_RESPONSE_BODY_CAP: number;

/**
 * Authenticated local-assistant tool routes for generated DeepSpace apps.
 *
 * The generated worker owns authentication policy; this SDK registrar only
 * consumes its verified access decision and executes the app's existing AI SDK
 * tools as that verified user.
 */

interface AgentToolRouteEnv {
    APP_NAME: string;
    DEEPSPACE_APP_ID: string;
    RECORD_ROOMS: DurableObjectNamespace;
}
/**
 * The generated worker distinguishes a missing identity (401), a denied
 * identity (403), and an access check it could not complete (503) — a
 * transient failure must not present as a permanent permission denial.
 */
type AgentToolAccessResult = {
    ok: true;
    auth: VerifyResult;
} | {
    ok: false;
    status: 401 | 403 | 503;
};
interface AgentToolRouteOptions<Env extends AgentToolRouteEnv> {
    /** Preserve the generated app's existing tool definitions unchanged. */
    buildTools: (executor: (toolName: string, params: Record<string, unknown>) => Promise<unknown>) => ToolSet;
    /** Performs app-specific authentication and authorization before tool discovery or execution. */
    resolveAccess: (request: Request, env: Env) => Promise<AgentToolAccessResult>;
}
interface UserToolExecutorEnv {
    DEEPSPACE_APP_ID: string;
    RECORD_ROOMS: DurableObjectNamespace;
}
/**
 * Execute one app tool in the canonical app RecordRoom as the verified user.
 * Every assistant surface (website chat, local agent) must share this path so
 * a tool behaves identically regardless of which surface invoked it.
 */
declare function createUserToolExecutor(env: UserToolExecutorEnv, userId: string, signal: AbortSignal): (toolName: string, params: Record<string, unknown>) => Promise<unknown>;
/**
 * Register the generated app's local assistant tool API.
 *
 * Mount before a broad `/_deepspace/*` proxy route so these SDK-owned paths
 * stay in the app Worker and retain the verified caller identity.
 */
declare function registerAgentToolRoutes<Env extends AgentToolRouteEnv>(app: Hono<{
    Bindings: Env;
}>, options: AgentToolRouteOptions<Env>): void;

/** First-party non-app origins retained for callers using the legacy policy shape. */
declare const PRODUCTION_OFFICIAL_AGENT_ORIGINS: readonly string[];
interface AgentTargetPolicy {
    appDomain: string;
    platformDomain?: string;
    allowLoopback?: boolean;
}
/** Normalize an agent target only when it is an exact trusted origin. */
declare function normalizeAgentTargetOrigin(value: unknown, policy: AgentTargetPolicy): string | null;

/**
 * Better Auth session cookie name. The CLI presents it when exchanging a
 * stored session for JWTs, and the auth worker requires it when minting —
 * the two sides must agree on the exact name.
 */
declare const SESSION_COOKIE = "__Secure-better-auth.session_token";

declare class BodyTooLargeError extends Error {
    readonly maxBytes: number;
    constructor(maxBytes: number);
}
/**
 * Read a Request or Response body under an exact byte ceiling. Content-Length
 * permits an early refusal, while streaming enforcement keeps chunked/forged
 * bodies from being fully allocated before the caller can reject them.
 */
declare function readBoundedBodyText(source: {
    headers: Headers;
    body: ReadableStream<Uint8Array> | null;
}, maxBytes: number): Promise<string>;

/**
 * `deepspace logs` wire DTO — the single source of truth for the whitelisted
 * shape the platform telemetry reader emits and every consumer reads, plus
 * the one plain-text rendering of it (`logEventText`).
 *
 * The producer is `platform/deploy-worker/src/lib/workers-logs.ts` (which
 * rebuilds each event field-by-field from a raw Cloudflare row — see the
 * security invariant there). The consumers are the CLI tail
 * (`cli/commands/logs.ts`), the dashboard Logs panel
 * (`apps/dashboard/src/lib/apps.ts`), and the e2e whitelist assertion
 * (`tests/e2e/tests/logs.spec.ts`). This module used to be hand-mirrored in
 * all four places, and the copies drifted for real: a field addition (the
 * since-removed `source`) landed in three of them and missed the e2e
 * whitelist. It now lives here once and they import it.
 *
 * Isomorphic — no DOM, no Hono, no platform types — so it re-exports cleanly
 * from both `deepspace` (client) and `deepspace/worker` and is safe to import
 * from the private deploy-worker.
 */
declare const LOG_LEVELS: readonly ["debug", "log", "info", "warn", "error"];
type LogLevel = (typeof LOG_LEVELS)[number];
/** One log / request / exception event, rebuilt field-by-field from a CF row. */
interface AppLogEvent {
    /** `$metadata.id` — unique per event; the client's dedupe key. */
    id: string;
    /** Unix ms. */
    timestamp: number;
    level: LogLevel;
    eventType: 'log' | 'request' | 'exception' | 'other';
    message: string;
    /**
     * The runtime's verdict on the invocation (`ok`, `exception`, `exceededCpu`,
     * `canceled`, …) — present on `request` and other invocation-summary events
     * only, never on a `log` line. It says whether the Worker RETURNED, not
     * whether the app succeeded: an action that throws inside the app's own
     * error handling and answers 500 is `ok` here. Triage failures on
     * `request.status`, `level`, and `eventType === 'exception'` (an exception
     * that escaped the Worker), not on `outcome !== 'ok'` alone.
     */
    outcome?: string;
    request?: {
        method: string;
        path: string;
        status?: number;
    };
    /**
     * The exception that ESCAPED the Worker (`eventType: 'exception'`). An
     * error the app catches and `console.error`s is a plain `log` line — and
     * the Workers runtime renders a logged Error OBJECT as its stack frames
     * without the message, so render it through `loggableError(err)` (below):
     * message first, bounded cause chain, capped at the reader's budget.
     */
    exception?: {
        name: string;
        message: string;
        stack?: string;
    };
}
interface AppLogsResponse {
    /** Ascending by timestamp (CF returns newest-first; the reader flips). */
    events: AppLogEvent[];
    /** Max event timestamp in ms — pass back as `since` to poll; null when empty. */
    cursor: number | null;
    /** True when the window returned `limit` events (older events were cut). */
    truncated: boolean;
    pollIntervalMs: number;
}
/**
 * Runtime tuple of every key a whitelisted `AppLogEvent` may carry — the
 * canonical whitelist the e2e suite mirrors when asserting no event leaks a key
 * outside this set. The two type-level assertions below fail compilation if
 * this tuple and the `AppLogEvent` interface disagree in either direction, so
 * adding an interface field forces a matching key here.
 *
 * NOTE: the e2e spec keeps its OWN copy of this set (it can't import the SDK —
 * `@deepspace/e2e` has no `deepspace` dependency), kept in step by a comment,
 * not by these compile-time guards. So this tuple hardens the code copies
 * (deploy-worker/CLI/dashboard, which import it), while the e2e mirror remains a
 * knowingly-accepted duplicate.
 */
declare const APP_LOG_EVENT_KEYS: readonly ["id", "timestamp", "level", "eventType", "message", "outcome", "request", "exception"];
type AppLogEventKey = (typeof APP_LOG_EVENT_KEYS)[number];
/**
 * One event → its plain-text body: what the event *says*, with no colors,
 * tags, timestamps, or stack frames — those belong to each renderer. Shared
 * by the CLI line formatter and the dashboard rows (which also use it as the
 * search corpus), so "does this event mention X" means the same thing in
 * both.
 */
declare function logEventText(e: AppLogEvent): string;
/**
 * An error as a string that survives Workers Logs ingestion. The telemetry
 * pipeline serializes a logged Error OBJECT down to its stack FRAMES — the
 * `Error: <message>` first line is dropped (observed 2026-08; Hono's default
 * handler does exactly `console.error(err)`, which is why an uncaught route
 * error showed up in `deepspace logs` as bare frames). A STRING passes
 * through verbatim. V8 stacks already open with `Error: <message>` (prefix
 * test, not substring); frames-only stacks get the header prepended; a
 * missing stack degrades to the header alone. `cause` chains and
 * `AggregateError.errors` are walked (bounded, cycle-safe) because the only
 * actionable text of the most common Workers error — `TypeError: fetch
 * failed` — lives there. Rendering is budgeted at every step: pieces are
 * sliced and the walk stops once MAX_LOG_TEXT_LENGTH is reached (error text
 * is often request-derived, and unbounded intermediates measured >100 MB on
 * hostile chains), and the final string never exceeds the budget the reader
 * truncates at (a call-site prefix can still push a full-budget line past
 * it — the reader re-cuts with the same `truncateLogText`). Never throws: a
 * hostile NODE (throwing getters, revoked Proxies, null-prototype
 * throwables) degrades to a tag IN PLACE so the rest of the render — the
 * part with the actionable message — survives. So:
 * `console.error(loggableError(err))`, never `console.error(err)`.
 */
declare function loggableError(err: unknown): string;
/**
 * Cut a string to `MAX_LOG_TEXT_LENGTH` INCLUDING the truncation marker —
 * the one truncation for log text, shared by the write side (`loggableError`)
 * and the read side (the deploy-worker reader's per-field cap), so the two
 * cannot drift. Steps back off a high surrogate so the cut never leaves a
 * lone half of a surrogate pair in the log line.
 */
declare function truncateLogText(s: string): string;
/** The one write-side budget for rendered error text, matching the reader's
 *  per-field cap (the deploy-worker's log reader imports this so the two
 *  sides cannot drift). The rendered string INCLUDING any truncation marker
 *  stays within it. */
declare const MAX_LOG_TEXT_LENGTH: number;

/**
 * The one `app.onError` for every Hono worker (the scaffolded app template
 * and the platform workers alike). It exists because Hono's default handler
 * is `console.error(err)` — and Workers Logs keeps only a logged Error
 * OBJECT's stack frames, dropping the message (see `loggableError`) — so an
 * uncaught route error surfaced in `deepspace logs` as bare frames.
 *
 * A response-bearing error (`HTTPException` — auth 401s, upload 413s) keeps
 * its own answer, exactly as Hono's default would; everything else is logged
 * as ONE string — `[prefix] METHOD /path: message, frames, bounded cause
 * chain` — and answered by `respond` (a plain-text 500 unless the worker's
 * API contract needs another shape).
 */
declare function workerErrorHandler(prefix: string, respond?: (c: Context) => Response): ErrorHandler;

export { ACCOUNT_STORAGE_LIMIT_BYTES, ACTION_ROUTES_BEARER_GUARD_MIGRATION_ID, ACTION_TOOLS_DELETE_WHERE_MIGRATION_ID, AGENT_TOKEN_SCOPE, AGENT_TOOL_REQUEST_BODY_CAP, AGENT_TOOL_RESPONSE_BODY_CAP, AI_CHATS_SCHEMA, AI_MESSAGES_SCHEMA, ALLOWED_BINDING_TYPES, ANONYMOUS_USER_ID_PREFIX, APP_ID_RE, APP_LOG_EVENT_KEYS, APP_NAME_RULES, ASSET_NOT_FOUND_HANDLING_VALUES, AUTO_PROVISIONABLE_TYPES, AUTO_PROVISION_SENTINEL, type ActionContext, type ActionHandler, type ActionResult, type ActionTools, type AgentTargetPolicy, type AgentToolAccessResult, type AgentToolRouteEnv, type AgentToolRouteOptions, type ApiErrorIssue, type ApiWorkerEnv, type AppLogEvent, type AppLogEventKey, type AppLogsResponse, type AppMembership, type AppMigrationIdsValidation, type AppNameResolution, type AppNameValidation, type AssetNotFoundHandling, type AuthWorkerEnv, Awareness, type AwarenessState, type AwarenessStates, BASE_USERS_SCHEMA, BROWSER_PROXY_ROUTES, BUILD_INJECTED_APP_ID_MIGRATION_ID, BUILT_IN_TOOLS, type BaseMessage, BaseRoom, type BindingJsonValue, BodyTooLargeError, CHANNELS_SCHEMA, CHANNEL_MEMBERS_SCHEMA, COST_RATES, CanvasRoom, type CanvasShape, type ChatContextConfig, type ChatMessageRow, type ChatRow, type ChatTurn, type ClientMessage, type CollectionSchema, type ColumnDefinition, type ColumnInterpretation, type ComposioToolsOptions, type ConnectionAttachment, type CronContext, type CronExecution, CronRoom, type CronRoomConfig, type CronTask, type CustomBinding, type CustomBindingManifest, DEEPSPACE_AGENT_PROFILES, DEEPSPACE_AI_DEFAULTS, DEEPSPACE_AI_MODELS, DEEPSPACE_MODEL_CATALOG_PROVENANCE, DEFAULT_CONTEXT_CONFIG, DEFAULT_DELETE_WHERE_LIMIT, DEFAULT_DO_MANIFEST, DEFAULT_QUERY_LIMIT, DEPLOYED_APPS_DEFAULTS, type DOBindings, type DOManifest, type DOManifestEntry, type DeepSpaceAIEnv, type DeepSpaceAIModel, type DeepSpaceAIModelId, type DeepSpaceAIOptions, type DeepSpaceAIProvider, type DeepSpaceAgentDiagnosticContext, DeepSpaceAgentModelError, type DeepSpaceAgentProfile, DeepSpaceAgentProfileError, type DeepSpaceAgentProfileId, type DeepSpaceAgentStream, type DeepSpaceAgentStreamOptions, type DeepSpaceAgentSupport, type DeepSpaceAuth, type DeepSpaceAuthConfig, type DeepSpaceDocumentationRouteEnv, type DeepSpaceDocumentationRouteOptions, type DoMigrationDirective, type DoMigrationPlan, type ExistingDOBinding, FILES_SESSION_COOKIE_READS_MIGRATION_ID, type GetActionData, type HandlerContext, type Job, type JobContext, JobRoom, type JobRoomConfig, type JobStatus, type JwtClaims, type JwtVerifierConfig, type KnowledgeAddOptions, type KnowledgeAddResult, type KnowledgeClient, type KnowledgeEnv, KnowledgeError, type KnowledgeItem, type KnowledgeListOptions, type KnowledgeListResult, type KnowledgeSearchChunk, type KnowledgeSearchOptions, type KnowledgeSearchResult, type KnowledgeStatus, LOG_LEVELS, type LogLevel, MAX_APP_FILE_BYTES, MAX_BINDING_NAME_LENGTH, MAX_DELETE_WHERE_LIMIT, MAX_DEPLOY_ASSET_FILE_BYTES, MAX_ENV_VAR_BYTES, MAX_LOG_TEXT_LENGTH, MAX_UPLOAD_PARTS, MAX_UPLOAD_REQUEST_BYTES, MESSAGES_SCHEMA, MSG, MSG_AWARENESS, MSG_SYNC, MSG_SYNC_STEP1, MSG_SYNC_STEP2, MSG_SYNC_UPDATE, MSG_YJS_AWARENESS, MSG_YJS_SYNC, type MessageHandlers, type MsgType, type MutateActionData, type NormalizedApiError, PRODUCTION_OFFICIAL_AGENT_ORIGINS, type PermissionContext, type PermissionLevel, type PlatformWorkerEnv, type PrefixResult, type PresencePeer, PresenceRoom, type ProtocolMessage, type ProxyRoute, type QueryActionData, REACTIONS_SCHEMA, READ_RECEIPTS_SCHEMA, RECORD_NOT_FOUND, REGISTRY_INSTANCE, RELEASE_STAMP_PATH, REPO_STORE_LIMIT_BYTES, REQUIRED_COMPATIBILITY_FLAGS, RESERVED_BINDING_NAMES, RESERVED_RUN_WORKER_FIRST, RESOURCE_ID_RE, ROLE_ADMIN, ROLE_ANONYMOUS, ROLE_DEFAULT, RecordRoom, type RecordRoomConfig, RegistryClientError, type ResolvedColumn, type ResolvedDeepSpaceAgentModel, type RolePermissions, type RunMigrationsResult, SDK_RUN_WORKER_FIRST, SECRET_NAME_RE, SECURE_ROOM_BOUNDARIES_MIGRATION_ID, SESSION_COOKIE, STRICT_APP_ID_RE, SYSTEM_ASSIGNED_COLUMNS, SYSTEM_COLLECTIONS, SYSTEM_MAINTAINED_COLUMNS, SYSTEM_MANAGED_COLUMNS, SchemaRegistry, type ScopeContext, type ScopedKnowledgeClient, type ScopedR2Auth, type ScopedR2Config, type ScopedR2Handler, type ScreenshotEnv, type ScreenshotResult, type ServerMessage, type StorageAdmission, type StoredRecord, type Summarizer, type SyncResult, TEST_ACCOUNT_EMAIL_SUFFIX, type TokenDebugInfo, type ToolResult, type ToolSchema, UNDECLARED_ASSET_NOT_FOUND_HANDLING, UPLOAD_PART_BYTES, USERS_COLUMNS, type User, type UserAttachment, type UserToolExecutorEnv, type ValidationError, type VerifiedAuth, type VerifyOutcome, type VerifyResult, type Viewport, WORKER_OWNED_NOT_FOUND_MIGRATION_ID, YjsRoom, agentTokenIssuer, apiWorkerFetch, appendMessage, applyAiToolDefaults, applySlidingWindow, armCronRoom, authWorkerFetch, authenticatedRoomRequest, bindingManifestFromOutputConfig, buildCronContext, buildTableSelect, buildUiParts, callRegistry, canCreate, canDelete, canRead, canUpdate, capToolResultSize, captureScreenshot, checkFieldPermissions, checkUnclaimedOwnerTransition, clientBuild, coerceValue, collectionTableName, columnId, composioTools, computeDoMigration, computeHmacHex, createChat, createDecoder, createDeepSpaceAI, createDeepSpaceAuth, createEncoder, createScopedR2Handler, createUserToolExecutor, dataToColumnValues, decodeJwtPayload, deepSpaceAgentErrorSummary, deleteChatCascade, dispatch, encode, encodeAwarenessMessage, encodeSyncStep1, encodeSyncStep2, encodeUpdate, enqueueJob, epochSeconds, folderFilter, formatBytes, getChat, getDeepSpaceAIModel, getMessageType, getRolePermissions, handleAwarenessMessage, handleSyncMessage, hasContent, isAnonymousUserId, isAssetNotFoundHandling, isAutoProvision, isFilesVerbPath, isOwner, isPlatformReservedPath, isTestAccountClaims, isTestAccountEmail, isTestAccountTier, knowledge, lintSchema, lintSchemaSet, lintSchemas, listDeepSpaceAgentModels, loadMessages, logEventText, loggableError, makeDefaultSummarizer, matchOrigin, meterAi, meterUsage, meterVectorize, mintAppId, mintUlid, noopPermissionContext, normalizeAgentTargetOrigin, normalizeApiError, normalizeKnowledgeFolder, parseQuotaLimit, platformCorsPatterns, platformWorkerFetch, prepareMessagesWithCompaction, priceBindingUsageEvent, readBoundedBodyText, readVarUint, readVarUint8Array, registerAgentToolRoutes, registerDeepSpaceDocumentation, registryErrorJson, registryStub, resolveAppMembership, resolveAppName, resolveAppRole, resolveColumn, resolveCompatibilityFlags, resolveDeepSpaceAgentModel, resolveSessionReadAuth, rowToData, runMigrations, serverBuild, storageLimitForTier, storageQuotaMessage, streamDeepSpaceAgent, timingSafeEqualHex, timingSafeEqualStrings, toUint8Array, totalChars, truncateLogText, truncateOldToolResults, turnsToCoreMessages, unwrapToolOutput, updateChat, validateAppMigrationIds, validateAppName, validateBindingManifest, validateDoManifest, verifyAgentToken, verifyJwt, workerErrorHandler, writeVarUint, writeVarUint8Array };