/**
 * Provider-neutral contract for the optional Redis runtime.
 *
 * Core owns feature semantics and stable facades. The extension owns Redis
 * packages, connections, protocol details, and transport lifecycle.
 *
 * @module extensions/distributed/redis-runtime-provider
 */
import type { ClaudeCodeEvent, ClaudeCodeEventHandler, ClaudeCodeEventPublisher, ClaudeCodeEventSubscriber } from "../../workflow/claude-code/types.js";
/** Registry name used by the Redis runtime extension. */
export declare const RedisRuntimeProviderName: "RedisRuntimeProvider";
/** Structural module surface used by the platform Redis adapter. */
export interface NodeRedisModule {
    createClient(options: {
        url?: string;
        socket?: {
            host?: string;
            port?: number;
            connectTimeout?: number;
            reconnectStrategy?: (retries: number) => number | Error;
        };
    }): NodeRedisClient;
}
/** Structural node-redis client surface used by the platform adapter. */
export interface NodeRedisClient {
    connect(): Promise<void>;
    hSet(key: string, fields: Record<string, string>): Promise<number | string>;
    hGetAll(key: string): Promise<Record<string, string>>;
    hDel(key: string, fields: string[]): Promise<number>;
    del(keys: string[]): Promise<number>;
    sAdd(key: string, members: string[]): Promise<number>;
    sRem(key: string, members: string[]): Promise<number>;
    sMembers(key: string): Promise<string[]>;
    rPush(key: string, values: string[]): Promise<number>;
    lRange(key: string, start: number, stop: number): Promise<string[]>;
    lIndex(key: string, index: number): Promise<string | null>;
    lSet(key: string, index: number, value: string): Promise<string | "OK">;
    lLen(key: string): Promise<number>;
    xAdd(key: string, id: string, fields: Record<string, string>): Promise<string>;
    xRead(streams: Array<{
        key: string;
        id: string;
    }>, options?: {
        BLOCK?: number;
        COUNT?: number;
    }): Promise<Array<{
        name: string;
        messages: Array<{
            id: string;
            message: Record<string, string>;
        }>;
    }> | null>;
    xGroupCreate(key: string, group: string, id: string, options?: {
        MKSTREAM?: boolean;
    }): Promise<string>;
    xReadGroup(group: string, consumer: string, streams: Array<{
        key: string;
        id: string;
    }>, options?: {
        BLOCK?: number;
        COUNT?: number;
    }): Promise<Array<{
        name: string;
        messages: Array<{
            id: string;
            message: Record<string, string>;
        }>;
    }> | null>;
    xAck(key: string, group: string, ids: string[]): Promise<number>;
    keys(pattern: string): Promise<string[]>;
    scan(cursor: number, options?: {
        MATCH?: string;
        COUNT?: number;
    }): Promise<{
        cursor: number;
        keys: string[];
    }>;
    exists(keys: string[]): Promise<number>;
    expire(key: string, seconds: number): Promise<number>;
    set(key: string, value: string, options?: {
        NX?: boolean;
        PX?: number;
        EX?: number;
    }): Promise<string | null>;
    get(key: string): Promise<string | null>;
    publish(channel: string, message: string): Promise<number>;
    subscribe(channel: string, listener: (message: string, channel: string) => void): Promise<void>;
    unsubscribe(channel: string): Promise<void>;
    eval(script: string, options?: {
        keys?: string[];
        arguments?: string[];
    }): Promise<unknown>;
    close(): Promise<void>;
    destroy(): void;
    on(event: "error", listener: (error: unknown) => void): unknown;
}
/** Structural client surface used by core cache features. */
export interface RedisClient {
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    get(key: string): Promise<string | null>;
    mGet(keys: string[]): Promise<Array<string | null>>;
    set(key: string, value: string, options?: {
        EX?: number;
        NX?: boolean;
    }): Promise<string | null>;
    del(key: string | string[]): Promise<number>;
    scan(cursor: number, options?: {
        MATCH?: string;
        COUNT?: number;
    }): Promise<{
        cursor: number;
        keys: string[];
    }>;
    expire(key: string, seconds: number): Promise<number>;
    eval(script: string, options: {
        keys: string[];
        arguments: string[];
    }): Promise<unknown>;
    incr(key: string): Promise<number>;
    pExpire(key: string, milliseconds: number): Promise<boolean>;
    pTTL(key: string): Promise<number>;
    ttl?(key: string): Promise<number>;
    info?(section?: "server" | "memory" | "cluster"): Promise<string>;
    on?(event: string, listener: (...args: unknown[]) => void): void;
    isOpen?: boolean;
}
/** Independently owned Redis connection returned to a core feature. */
export interface RedisClientHandle {
    readonly client: RedisClient;
    close(): Promise<void>;
}
/** Connection options accepted by the stable core Redis client facade. */
export interface RedisClientOptions {
    url?: string;
    connectTimeout?: number;
    autoReconnect?: boolean;
    tls?: boolean;
    password?: string;
    username?: string;
}
/** Redis Pub/Sub publisher configuration. */
export interface RedisEventPublisherConfig {
    /** Redis URL. */
    url: string;
    /** Channel prefix (default: `claude-code`). */
    channelPrefix?: string;
    /** Enable debug logging. */
    debug?: boolean;
}
/** Redis-backed event publisher/subscriber implementation. */
export interface RedisEventPublisherImplementation extends ClaudeCodeEventPublisher, ClaudeCodeEventSubscriber {
    publish(event: ClaudeCodeEvent): Promise<void>;
    subscribe(runId: string, handler: ClaudeCodeEventHandler): Promise<() => void>;
    close(): Promise<void>;
}
/** Optional Redis runtime implementation supplied by an extension. */
export interface RedisRuntimeProvider {
    readonly id: string;
    loadModule(): Promise<NodeRedisModule>;
    getClient(options?: RedisClientOptions): Promise<RedisClient>;
    disconnectClient(): Promise<void>;
    openClient(options?: RedisClientOptions, signal?: AbortSignal): Promise<RedisClientHandle>;
    createEventPublisher(config: RedisEventPublisherConfig): Promise<RedisEventPublisherImplementation>;
    close(): Promise<void>;
}
/**
 * Validate and snapshot a provider before core invokes extension-owned code.
 * Accessors are rejected so registration cannot execute code during capture.
 */
export declare function captureRedisRuntimeProvider(value: unknown): Readonly<RedisRuntimeProvider>;
//# sourceMappingURL=redis-runtime-provider.d.ts.map