import { P as ProvidedClientTransportOptions, e as ProvidedServerTransportOptions, n as ClientHandshakeOptions, C as Connection, r as ServerHandshakeOptions, T as Transport, i as SessionNoConnection, y as SessionBoundSendFn, m as ClientTransportOptions, z as SessionOptions } from '../transport-DF2T202E.js';
import { C as ClientTransport } from '../client-C8pwDvTN.js';
import { TSchema, Static } from 'typebox';
import { C as CustomHandshakeErrorCodeSchema, T as TransportClientId, h as PartialTransportMessage, O as OpaqueTransportMessage } from '../message-C2qDAau6.js';
import { B as BaseErrorSchemaType, s as Readable, a1 as ReadableIterator, u as ReadableResult } from '../services-DPANPmhb.js';
import { W as WsLike } from '../wslike-Dng9H1C7.js';
import NodeWs from 'ws';
import http from 'node:http';
import { S as ServerTransport } from '../server-D88e2r09.js';
import { Duplex } from 'node:stream';
import '../index-CIMpdW6z.js';
import '../types-BGGvYIJM.js';
import '../adapter-K2HsfQLt.js';
import '@opentelemetry/api';

interface TestTransportOptions {
    client?: ProvidedClientTransportOptions;
    server?: ProvidedServerTransportOptions;
}
interface TestSetupHelpers {
    getClientTransport: <RejectionCodeSchema extends CustomHandshakeErrorCodeSchema = never>(id: TransportClientId, handshakeOptions?: ClientHandshakeOptions<TSchema, RejectionCodeSchema>) => ClientTransport<Connection, RejectionCodeSchema>;
    getServerTransport: <MetadataSchema extends TSchema = TSchema, ParsedMetadata extends object = object, RejectionCodeSchema extends CustomHandshakeErrorCodeSchema = never>(id?: TransportClientId, handshakeOptions?: ServerHandshakeOptions<MetadataSchema, ParsedMetadata, RejectionCodeSchema>) => ServerTransport<Connection, MetadataSchema, ParsedMetadata, RejectionCodeSchema>;
    simulatePhantomDisconnect: () => void;
    restartServer: () => Promise<void>;
    cleanup: () => Promise<void> | void;
}

declare class InMemoryConnection extends Connection {
    conn: Duplex;
    constructor(pipe: Duplex);
    send(payload: Uint8Array): boolean;
    close(): void;
}
declare function createMockTransportNetwork(opts?: TestTransportOptions): TestSetupHelpers;

/**
 * Creates a WebSocket client that connects to a local server at the specified port.
 * This should only be used for testing.
 * @param port - The port number to connect to.
 * @returns A Promise that resolves to a WebSocket instance.
 */
declare function createLocalWebSocketClient(port: number): WsLike;
/**
 * Creates a WebSocket server instance using the provided HTTP server.
 * Only used as helper for testing.
 * @param server - The HTTP server instance to use for the WebSocket server.
 * @returns A Promise that resolves to the created WebSocket server instance.
 */
declare function createWebSocketServer(server: http.Server): NodeWs.Server<typeof NodeWs, typeof http.IncomingMessage>;
/**
 * Starts listening on the given server and returns the automatically allocated port number.
 * This should only be used for testing.
 * @param server - The http server to listen on.
 * @returns A promise that resolves with the allocated port number.
 * @throws An error if a port cannot be allocated.
 */
declare function onWsServerReady(server: http.Server): Promise<number>;
/**
 * A safe way to access {@link Readble}'s iterator multiple times in test helpers.
 *
 * If there are other iteration attempts outside of the test helpers
 * (this function, {@link readNextResult}, and {@link isReadableDone})
 * it will throw an error.
 */
declare function getReadableIterator<T, E extends Static<BaseErrorSchemaType>>(readable: Readable<T, E>): ReadableIterator<T, E>;
/**
 * Retrieves the next value from {@link Readable}, or throws an error if the Readable is done.
 *
 * Calling semantics are similar to {@link getReadableIterator}
 */
declare function readNextResult<T, E extends Static<BaseErrorSchemaType>>(readable: Readable<T, E>): Promise<ReadableResult<T, E>>;
/**
 * Checks if the readable is done iterating, it consumes an iteration in the process.
 *
 * Calling semantics are similar to {@link getReadableIterator}
 */
declare function isReadableDone<T, E extends Static<BaseErrorSchemaType>>(readable: Readable<T, E>): Promise<boolean>;
declare function payloadToTransportMessage<Payload>(payload: Payload): PartialTransportMessage<Payload>;
declare function createDummyTransportMessage(): PartialTransportMessage<{
    msg: string;
    test: number;
}>;
/**
 * Waits for a message on the transport.
 * @param {Transport} t - The transport to listen to.
 * @param filter - An optional filter function to apply to the received messages.
 * @returns A promise that resolves with the payload of the first message that passes the filter.
 */
declare function waitForMessage(t: Transport<Connection>, filter?: (msg: OpaqueTransportMessage) => boolean, rejectMismatch?: boolean): Promise<unknown>;
declare const testingSessionOptions: SessionOptions;
declare const testingClientSessionOptions: ClientTransportOptions;
declare function dummySession(): SessionNoConnection;
declare function getClientSendFn<ClientRejectionCodeSchema extends CustomHandshakeErrorCodeSchema>(clientTransport: ClientTransport<Connection, ClientRejectionCodeSchema>, serverTransport: {
    clientId: string;
}): SessionBoundSendFn;
declare function getServerSendFn<HandshakeFailureCode extends string>(serverTransport: Transport<Connection, HandshakeFailureCode>, clientTransport: {
    clientId: string;
}): SessionBoundSendFn;
declare function getTransportConnections<ConnType extends Connection, HandshakeFailureCode extends string>(transport: Transport<ConnType, HandshakeFailureCode>): Array<ConnType>;
declare function numberOfConnections<ConnType extends Connection, HandshakeFailureCode extends string>(transport: Transport<ConnType, HandshakeFailureCode>): number;
declare function closeAllConnections<ConnType extends Connection, HandshakeFailureCode extends string>(transport: Transport<ConnType, HandshakeFailureCode>): void;
/**
 * Wraps a partial context object in a proxy that throws when accessing
 * properties that weren't provided. This is useful for test contexts where
 * you only want to mock the dependencies a test actually uses.
 *
 * Symbols and `then` are allowed through without throwing — river checks
 * for `Symbol.asyncDispose` / `Symbol.dispose` on context values during
 * `server.close()`, and `then` is checked by the JS runtime when the
 * proxy is returned from an async function.
 *
 * @example
 * ```ts
 * const ctx = createPartialContext<MyContext>({
 *   database: mockDb,
 *   // accessing ctx.redis will throw
 * });
 *
 * const server = createServer(transport, services, {
 *   extendedContext: ctx,
 * });
 * ```
 */
declare function createPartialContext<T extends Record<string, unknown>>(partial: Partial<T>): T;

export { InMemoryConnection, closeAllConnections, createDummyTransportMessage, createLocalWebSocketClient, createMockTransportNetwork, createPartialContext, createWebSocketServer, dummySession, getClientSendFn, getReadableIterator, getServerSendFn, getTransportConnections, isReadableDone, numberOfConnections, onWsServerReady, payloadToTransportMessage, readNextResult, testingClientSessionOptions, testingSessionOptions, waitForMessage };