import type { Lock, Logger, QueueEntry, StateAdapter } from "chat";
import type { FunctionArgs, FunctionReference, FunctionReturnType } from "convex/server";
import type { ComponentApi } from "../component/_generated/component.js";
/**
 * The subset of a Convex action/mutation `ctx` we need. Any `ActionCtx` or
 * `MutationCtx` from the installing app satisfies this shape.
 *
 * The component's functions are `"internal"` from the app's perspective, so
 * we constrain to that visibility.
 */
export type RunComponentCtx = {
    runMutation: <Mutation extends FunctionReference<"mutation", "internal">>(mutation: Mutation, args: FunctionArgs<Mutation>) => Promise<FunctionReturnType<Mutation>>;
    runQuery: <Query extends FunctionReference<"query", "internal">>(query: Query, args: FunctionArgs<Query>) => Promise<FunctionReturnType<Query>>;
};
export interface ConvexCtxStateAdapterOptions {
    /** A Convex action or mutation `ctx` with `runMutation`/`runQuery`. */
    ctx: RunComponentCtx;
    /** The mounted component reference, typically `components.chatState`. */
    component: ComponentApi;
    /** Namespace for all rows. Default: `"chat-sdk"`. */
    keyPrefix?: string;
    /** Logger instance for error reporting. */
    logger?: Logger;
}
/**
 * Chat SDK state adapter that runs inside a Convex action or httpAction.
 *
 * Unlike `ConvexStateAdapter` (which uses a `ConvexHttpClient` from an
 * external process), this variant calls the component directly via
 * `ctx.runMutation` / `ctx.runQuery`. No wrapper file is needed — the
 * calls go straight to `components.chatState.*`.
 *
 * Use this when your Chat SDK webhook handler lives inside a Convex
 * `httpAction`. Use `ConvexStateAdapter` when the handler lives in an
 * external runtime (Next.js route, Cloudflare Worker, etc.).
 */
export declare class ConvexCtxStateAdapter implements StateAdapter {
    private readonly ctx;
    private readonly component;
    private readonly keyPrefix;
    private readonly logger;
    private connected;
    constructor(options: ConvexCtxStateAdapterOptions);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    subscribe(threadId: string): Promise<void>;
    unsubscribe(threadId: string): Promise<void>;
    isSubscribed(threadId: string): Promise<boolean>;
    acquireLock(threadId: string, ttlMs: number): Promise<Lock | null>;
    releaseLock(lock: Lock): Promise<void>;
    forceReleaseLock(threadId: string): Promise<void>;
    extendLock(lock: Lock, ttlMs: number): Promise<boolean>;
    get<T = unknown>(key: string): Promise<T | null>;
    set<T = unknown>(key: string, value: T, ttlMs?: number): Promise<void>;
    setIfNotExists(key: string, value: unknown, ttlMs?: number): Promise<boolean>;
    delete(key: string): Promise<void>;
    appendToList(key: string, value: unknown, options?: {
        maxLength?: number;
        ttlMs?: number;
    }): Promise<void>;
    getList<T = unknown>(key: string): Promise<T[]>;
    enqueue(threadId: string, entry: QueueEntry, maxSize: number): Promise<number>;
    dequeue(threadId: string): Promise<QueueEntry | null>;
    queueDepth(threadId: string): Promise<number>;
    private ensureConnected;
}
export declare function createConvexStateFromCtx(options: ConvexCtxStateAdapterOptions): ConvexCtxStateAdapter;
//# sourceMappingURL=ctx.d.ts.map