import { R as Row, T as Transport, Q as QueryResult, a as TransactionOptions } from './types-YTdPe6Qz.js';

/**
 * RpcPromise - A promise wrapper that supports capnweb magic map and pipelining
 *
 * This class enables:
 * - Magic map support for N+1 query elimination
 * - Promise pipelining for batched operations
 * - Lazy execution (queries don't execute until awaited or .map()'d)
 *
 * @example Magic Map
 * ```typescript
 * const usersWithOrders = await db.query('SELECT * FROM users')
 *   .map(users => Promise.all(
 *     users.map(u => db.query('SELECT * FROM orders WHERE user_id = $1', [u.id]))
 *   ))
 * ```
 *
 * @example Promise Pipelining
 * ```typescript
 * const user = db.query('SELECT * FROM users WHERE id = $1', [id])
 * const posts = user.map(u => db.query('SELECT * FROM posts WHERE author = $1', [u.id]))
 * const comments = posts.map(p => db.query('SELECT * FROM comments WHERE post_id = ANY($1)', [p.map(x => x.id)]))
 * const result = await comments // Single round trip!
 * ```
 */

/**
 * Execution context for RPC pipelining
 * Accumulates queries that can be batched together
 */
interface RpcExecutionContext {
    /** Add a query to the batch */
    addQuery(sql: string, params?: unknown[]): number;
    /** Execute all batched queries */
    executeBatch(): Promise<BatchResult[]>;
    /** Get a pending result by query ID */
    getResult(queryId: number): Promise<unknown>;
    /** Check if the context is currently collecting queries */
    isCollecting(): boolean;
    /** Start collecting queries for batching */
    startCollecting(): void;
    /** Stop collecting and execute batch */
    stopCollecting(): Promise<void>;
}
/**
 * Result from a batched query
 */
interface BatchResult<T = unknown> {
    queryId: number;
    rows: T[];
    fields: Array<{
        name: string;
        dataTypeID: number;
    }>;
    rowCount: number;
    durationMs: number;
}
/**
 * Map function signature for RpcPromise
 */
type MapFn<T, U> = (value: T) => U | Promise<U>;
/**
 * RpcPromise implementation
 * Wraps a query operation with magic map and pipelining support
 */
declare class RpcPromise<T> implements PromiseLike<T> {
    private executor;
    private cachedResult;
    private executed;
    private executing;
    private context;
    constructor(executor: () => Promise<T>, context?: RpcExecutionContext | null);
    /**
     * Map over the result with magic map support
     *
     * The map function receives the resolved value and can return:
     * - A plain value
     * - A Promise
     * - Another RpcPromise (for pipelining)
     *
     * When the callback returns RpcPromises, they are batched together
     * with the original query for efficient execution.
     *
     * @example
     * ```typescript
     * const usersWithPosts = db.query('SELECT * FROM users')
     *   .map(users => Promise.all(
     *     users.map(u => db.query('SELECT * FROM posts WHERE user_id = $1', [u.id]))
     *   ))
     * ```
     */
    map<U>(fn: MapFn<T, U>): RpcPromise<U>;
    /**
     * FlatMap for when the map function returns an RpcPromise
     */
    flatMap<U>(fn: (value: T) => RpcPromise<U>): RpcPromise<U>;
    /**
     * Execute the query and return the result
     */
    execute(): Promise<T>;
    /**
     * Reset the execution state to allow re-execution
     */
    reset(): void;
    /**
     * Check if the promise has been executed
     */
    isExecuted(): boolean;
    /**
     * PromiseLike implementation - makes this thenable
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
    /**
     * Catch handler
     */
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
    /**
     * Finally handler
     */
    finally(onfinally?: (() => void) | null): Promise<T>;
}
/**
 * Create an RpcPromise from a query function
 */
declare function createRpcPromise<T>(executor: () => Promise<T>, context?: RpcExecutionContext | null): RpcPromise<T>;
/**
 * Query result type for typed queries
 */
interface RpcQueryResult<T extends Row = Row> {
    rows: T[];
    fields: Array<{
        name: string;
        dataTypeID: number;
    }>;
    rowCount: number;
    durationMs: number;
}
/**
 * Create an RpcPromise that extracts rows from a query result
 */
declare function createRowsPromise<T extends Row = Row>(executor: () => Promise<RpcQueryResult<T>>, context?: RpcExecutionContext | null): RpcPromise<T[]>;
/**
 * Batch multiple RpcPromises for efficient execution
 *
 * This collects all queries from the provided promises and executes
 * them in a single batch, then distributes the results.
 *
 * @example
 * ```typescript
 * const [users, orders, products] = await batchExecute([
 *   db.query('SELECT * FROM users'),
 *   db.query('SELECT * FROM orders'),
 *   db.query('SELECT * FROM products'),
 * ])
 * ```
 */
declare function batchExecute<T extends readonly RpcPromise<unknown>[]>(promises: T): Promise<{
    [K in keyof T]: T[K] extends RpcPromise<infer U> ? U : never;
}>;
/**
 * Create a magic map wrapper that batches nested queries
 *
 * This enables the N+1 query elimination pattern:
 * ```typescript
 * const usersWithOrders = await magicMap(
 *   db.query('SELECT * FROM users'),
 *   users => users.map(u => db.query('SELECT * FROM orders WHERE user_id = $1', [u.id]))
 * )
 * ```
 */
declare function magicMap<T, U>(source: RpcPromise<T[]>, mapFn: (items: T[]) => RpcPromise<U>[]): Promise<U[]>;

/**
 * RPC Transport for postgres.do
 *
 * Connects to PostgresDO via capnweb RPC for:
 * - Direct Worker-to-DO communication without HTTP overhead
 * - Promise pipelining for efficient batched operations
 * - Magic map support for N+1 query elimination
 *
 * @see packages/postgres/src/worker/rpc.ts for the server-side RPC API
 * @see packages/postgres/src/worker/proxy.ts for the proxy session pool
 */

/**
 * RPC Transport configuration
 */
interface RpcTransportConfig {
    /** WebSocket URL for the capnweb RPC endpoint */
    url: string;
    /** API key for authentication */
    apiKey?: string | undefined;
    /** Custom WebSocket implementation */
    WebSocket?: typeof WebSocket | undefined;
    /** Connection timeout in milliseconds */
    connectTimeout?: number | undefined;
    /** Request timeout in milliseconds */
    requestTimeout?: number | undefined;
    /** Enable automatic batching */
    autoBatch?: boolean | undefined;
    /** Batch delay in milliseconds (how long to wait for more queries) */
    batchDelayMs?: number | undefined;
}
/**
 * RPC Transport implementation
 *
 * Provides capnweb-style RPC communication with PostgresDO:
 * - Automatic query batching for N+1 elimination
 * - Promise pipelining support
 * - WebSocket-based persistent connection
 */
declare class RpcTransport implements Transport, RpcExecutionContext {
    private readonly config;
    private readonly WebSocketImpl;
    private ws;
    private connected;
    private authenticated;
    private connecting;
    private requestId;
    private pendingRequests;
    private pendingBatch;
    private collecting;
    constructor(config: RpcTransportConfig);
    /**
     * Add a query to the current batch
     */
    addQuery(sql: string, params?: unknown[]): number;
    /**
     * Execute all batched queries
     */
    executeBatch(): Promise<BatchResult[]>;
    /**
     * Get a pending result by query ID
     */
    getResult(_queryId: number): Promise<unknown>;
    /**
     * Check if the context is currently collecting queries
     */
    isCollecting(): boolean;
    /**
     * Start collecting queries for batching
     */
    startCollecting(): void;
    /**
     * Stop collecting and execute batch
     */
    stopCollecting(): Promise<void>;
    /**
     * Flush the pending batch immediately
     */
    private flushBatch;
    /**
     * Execute a SQL query with RpcPromise support
     */
    queryRpc<T extends Row = Row>(sql: string, params?: unknown[]): RpcPromise<T[]>;
    /**
     * Execute a SQL query and return full result
     */
    query<T extends Row = Row>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
    /**
     * Execute a batch of queries
     */
    batch<T extends Row = Row>(queries: Array<{
        sql: string;
        params?: unknown[];
    }>): Promise<Array<QueryResult<T>>>;
    /**
     * Execute a batch of queries within a transaction
     */
    batchTransaction<T extends Row = Row>(queries: Array<{
        sql: string;
        params?: unknown[];
    }>, options?: TransactionOptions): Promise<Array<QueryResult<T>>>;
    /**
     * Execute multiple queries in a transaction (Transport interface)
     */
    transaction<T>(queries: Array<{
        sql: string;
        params?: unknown[];
    }>, options?: TransactionOptions): Promise<T>;
    /**
     * Close the WebSocket connection
     */
    close(): Promise<void>;
    /**
     * Check if transport is connected
     */
    isConnected(): boolean;
    /**
     * Ensure the WebSocket is connected and authenticated
     */
    private ensureConnected;
    /**
     * Establish WebSocket connection
     */
    private connect;
    /**
     * Authenticate with the API key
     */
    private authenticate;
    /**
     * Send a request and wait for response
     */
    private sendRequest;
    /**
     * Handle incoming WebSocket message
     */
    private handleMessage;
    /**
     * Reject all pending requests
     */
    private rejectAllPending;
    /**
     * Get next request ID
     */
    private nextRequestId;
    /**
     * Serialize transaction options
     */
    private serializeTransactionOptions;
}
/**
 * Create an RPC transport instance
 */
declare function createRpcTransport(config: RpcTransportConfig): RpcTransport;

export { type BatchResult as B, type MapFn as M, RpcTransport as R, type RpcTransportConfig as a, RpcPromise as b, createRpcTransport as c, createRpcPromise as d, createRowsPromise as e, batchExecute as f, type RpcExecutionContext as g, type RpcQueryResult as h, magicMap as m };