/**
 * ThreadForge Built-in Plugins
 *
 *   import { redis, postgres, s3, cors, cron, realtime } from 'threadforge/plugins';
 */
import type { IncomingMessage, ServerResponse } from "node:http";
import type { Socket } from "node:net";
import type { HealthCheckResult, IoRedisLikeClient, NginxResult, PluginContext, PostgresOptions, RedisOptions } from "./types.js";
type RespValue = string | number | Buffer | null | Error | RespValue[];
interface PendingRequest {
    ok: (val: RespValue) => void;
    no: (err: Error) => void;
}
interface RedisClient {
    status: string;
    get(key: string): Promise<string | null>;
    set(...args: string[]): Promise<RespValue>;
    del(...keys: string[]): Promise<RespValue>;
    hget(key: string, field: string): Promise<string | null>;
    hset(key: string, field: string, value: string): Promise<RespValue>;
    hgetall(key: string): Promise<Record<string, string>>;
    keys(pattern: string): Promise<string[] | RespValue>;
    expire(key: string, seconds: string): Promise<RespValue>;
    ttl(key: string): Promise<RespValue>;
    ping(): Promise<RespValue>;
    incr(key: string): Promise<RespValue>;
    decr(key: string): Promise<RespValue>;
    lpush(key: string, ...values: string[]): Promise<RespValue>;
    rpush(key: string, ...values: string[]): Promise<RespValue>;
    lrange(key: string, start: string | number, end: string | number): Promise<string[] | RespValue>;
    sadd(key: string, ...members: string[]): Promise<RespValue>;
    smembers(key: string): Promise<string[] | RespValue>;
    publish(channel: string, message: string): Promise<RespValue>;
    subscribe(channel: string, callback: (message: string, channel: string) => void): Promise<void>;
    psubscribe(pattern: string, callback: (message: string, channel: string, pattern: string) => void): Promise<void>;
    quit(): Promise<void | undefined | RespValue>;
    disconnect(): void;
    _subSocket: Socket | null;
    _subConnected: boolean;
    _subBufChunks: Buffer[];
    _subBufTotalLen: number;
    _subCallbacks: Map<string, Set<(message: string, channel: string) => void>>;
    _psubCallbacks: Map<string, Set<(message: string, channel: string, pattern: string) => void>>;
    _subSubscribedChannels: Set<string>;
    _subSubscribedPatterns: Set<string>;
    _subRq: PendingRequest[];
    _ensureSubConnection(): Promise<void>;
    _scheduleSubReconnect(): void;
    _subCmd(...args: string[]): Promise<RespValue>;
    _flushSub(): void;
    _poolConnections?: RedisClient[];
}
interface RedisPlugin {
    name: "redis";
    version: string;
    inject: "redis";
    validate(): void;
    env(): Record<string, string>;
    connect(ctx: PluginContext): Promise<RedisClient | IoRedisLikeClient>;
    healthCheck(c: RedisClient | IoRedisLikeClient): Promise<HealthCheckResult>;
    disconnect(c: RedisClient | IoRedisLikeClient): Promise<void>;
    metrics(c: RedisClient | IoRedisLikeClient): Record<string, number>;
    nginx(): NginxResult;
}
interface PgPool {
    query(...args: unknown[]): Promise<unknown>;
    connect(): Promise<{
        release(): void;
    }>;
    end(): Promise<void>;
    totalCount: number;
    idleCount: number;
    waitingCount: number;
}
interface PostgresPlugin {
    name: "postgres";
    version: string;
    inject: "pg";
    injectAs: "postgres";
    validate(): void;
    env(): Record<string, string>;
    connect(ctx: PluginContext): Promise<PgPool>;
    healthCheck(pool: PgPool): Promise<HealthCheckResult>;
    disconnect(pool: PgPool): Promise<void>;
    metrics(pool: PgPool): Record<string, number>;
    nginx(): NginxResult;
}
interface S3Options {
    bucket?: string;
    endpoint?: string;
    region?: string;
}
interface S3RealClient {
    _isStub: false;
    _raw: unknown;
    _HeadBucketCommand: new (params: {
        Bucket: string;
    }) => unknown;
    put(key: string, body: Buffer | string, contentType?: string): Promise<unknown>;
    get(key: string): Promise<unknown>;
    del(key: string): Promise<unknown>;
    url(key: string): string;
    bucket: string;
}
interface S3StubClient {
    _isStub: true;
    put(key: string, body: Buffer | string): Promise<void>;
    get(key: string): Promise<Buffer | string | null>;
    del(key: string): Promise<void>;
    url(key: string): string;
    bucket: string;
}
type S3Client = S3RealClient | S3StubClient;
interface S3Plugin {
    name: "s3";
    version: string;
    inject: "storage";
    injectAs: "s3";
    validate(): void;
    env(): Record<string, string>;
    connect(ctx: PluginContext): Promise<S3Client>;
    healthCheck(s: S3Client): Promise<HealthCheckResult>;
    disconnect(): Promise<void>;
}
interface CorsOptions {
    origins?: string[];
    methods?: string[];
    headers?: string[];
    credentials?: boolean;
    maxAge?: number;
}
interface CorsConfig {
    origins: string[];
    methods: string[];
    headers: string[];
}
type NextFunction = () => void;
interface CorsPlugin {
    name: "cors";
    version: string;
    inject: "_cors";
    validate(): void;
    connect(): Promise<CorsConfig>;
    middleware(): (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
    disconnect(): Promise<void>;
}
interface WebSocketLike {
    send(data: string): void;
    sendBinary?(data: Buffer): void;
    close?(code?: number, reason?: string): void;
    socket?: Socket;
    _closed?: boolean;
}
interface RealtimeDecision {
    allow: boolean;
    statusCode?: number;
    reason?: string;
    closeCode?: number;
    closeReason?: string;
    headers?: Record<string, string>;
}
interface AuthorizePayload {
    stage: string;
    ws?: WebSocketLike;
    req?: IncomingMessage;
    meta?: Record<string, unknown>;
    [key: string]: unknown;
}
type AuthorizeHook = (payload: AuthorizePayload) => RealtimeDecision | boolean | null | undefined | Promise<RealtimeDecision | boolean | null | undefined>;
interface RealtimeOptions {
    adapter?: "memory" | "redis";
    redisUrl?: string;
    busChannel?: string;
    maxPayloadBytes?: number;
    maxConnections?: number;
    maxSocketBufferBytes?: number;
    backpressureStrategy?: "drop" | "close";
    redisSubHealthcheckMs?: number;
    strictBusPublish?: boolean;
    authorize?: AuthorizeHook;
    authorizeUpgrade?: AuthorizeHook;
    authorizeConnect?: AuthorizeHook;
    allowedChannels?: string[];
}
interface RealtimeMetrics {
    connections: number;
    channels: number;
    published: number;
    delivered: number;
    dropped: number;
    backpressureDropped: number;
    busPublishErrors: number;
    redisReconnects: number;
}
interface RealtimeAttachResult {
    join(channel: string): boolean;
    leave(channel: string): boolean;
    publish(channel: string, payload: unknown): Promise<{
        delivered: number;
        busPublished: boolean;
    }>;
    detach(): void;
}
interface RealtimeClient {
    adapter: string;
    busChannel: string;
    join(ws: WebSocketLike, channel: string): boolean;
    leave(ws: WebSocketLike, channel: string): boolean;
    publish(channel: string, payload: unknown, opts?: {
        excludeWs?: WebSocketLike | null;
    }): Promise<{
        delivered: number;
        busPublished: boolean;
    }>;
    broadcast(payload: unknown, opts?: {
        excludeWs?: WebSocketLike | null;
    }): Promise<{
        delivered: number;
        busPublished: boolean;
    }>;
    attach(ws: WebSocketLike, attachOptions?: {
        req?: IncomingMessage | null;
        meta?: Record<string, unknown> | null;
        channels?: string[];
    }): RealtimeAttachResult;
    channels(): string[];
    connectionCount(): number;
    _onWsUpgrade(hookCtx: Record<string, unknown>): Promise<RealtimeDecision>;
    _onWsConnect(hookCtx: {
        ws: WebSocketLike;
        req?: IncomingMessage;
        meta?: Record<string, unknown>;
    }): Promise<RealtimeDecision>;
    _registerConnection(ws: WebSocketLike, req?: IncomingMessage | null, meta?: Record<string, unknown> | null): void;
    _cleanupConnection(ws: WebSocketLike): void;
    _metrics(): RealtimeMetrics;
    _shutdown(): Promise<void>;
}
interface RealtimePlugin {
    name: "realtime";
    version: string;
    inject: "realtime";
    validate(): void;
    env(): Record<string, string>;
    connect(ctx: PluginContext): Promise<RealtimeClient>;
    disconnect(client: RealtimeClient): Promise<void>;
    metrics(client: RealtimeClient): RealtimeMetrics;
    onWsUpgrade(client: RealtimeClient, ctx: Record<string, unknown>): Promise<RealtimeDecision> | undefined;
    onWsConnect(client: RealtimeClient, ctx: Record<string, unknown>): Promise<RealtimeDecision | undefined>;
    onWsClose(client: RealtimeClient, ctx: {
        ws: WebSocketLike;
    }): void;
}
interface CronOptions {
    leaderOnly?: boolean;
}
interface CronScheduleOptions {
    immediate?: boolean;
    timezone?: string;
}
interface CronJobEntry {
    expr: string;
    timer: ReturnType<typeof setInterval> | ReturnType<typeof setTimeout>;
    _cancelComplex?: () => void;
}
interface CronClient {
    jobs: Map<string, CronJobEntry>;
    schedule(name: string, expr: string, fn: () => Promise<void> | void, options?: CronScheduleOptions): void;
    cancel(name: string): void;
    listJobs(): string[];
    _timers: (ReturnType<typeof setInterval> | ReturnType<typeof setTimeout>)[];
}
interface CronPlugin {
    name: "cron";
    version: string;
    inject: "cron";
    connect(ctx: PluginContext): Promise<CronClient>;
    disconnect(c: CronClient): Promise<void>;
}
export declare function redis(options?: RedisOptions): RedisPlugin;
/** @internal Exported for testing only */
export declare function _mkRedis(url: string, ctx: PluginContext): Promise<RedisClient>;
export declare function postgres(options?: PostgresOptions): PostgresPlugin;
export declare function s3(options?: S3Options): S3Plugin;
export declare function cors(options?: CorsOptions): CorsPlugin;
export declare function realtime(options?: RealtimeOptions): RealtimePlugin;
export declare function cron(options?: CronOptions): CronPlugin;
export {};
//# sourceMappingURL=index.d.ts.map