import type { AllButLast, DecorateAcknowledgements, EventNames, EventNamesWithError, EventParams, EventsMap, FirstNonErrorArg, Last, TypedEventBroadcaster } from '../types/typed-events';
import { type DefaultSocketData } from '../types/socket-types';
import type { Adapter, Room } from './socket.io-adapter';
import type { Socket } from './socket';
export interface BroadcastFlags {
    volatile?: boolean;
    compress?: boolean;
    local?: boolean;
    broadcast?: boolean;
    timeout?: number;
    binary?: boolean;
}
/**
 * Simplified BroadcastOperator with only emit and emitWithAck
 */
export declare class BroadcastOperator<
/** {@link TypedEventBroadcaster} */
EmitEvents extends EventsMap, SocketData extends DefaultSocketData> implements TypedEventBroadcaster<EmitEvents> {
    private readonly adapter;
    private readonly rooms;
    private readonly exceptRooms;
    private readonly flags;
    private readonly socket?;
    constructor(adapter: Adapter, rooms?: Set<Room>, exceptRooms?: Set<Room>, flags?: BroadcastFlags & {
        expectSingleResponse?: boolean;
    }, socket?: Socket | undefined);
    /**
     * Target specific room(s)
     */
    to(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
    /**
     * Target specific room(s) - alias for to()
     */
    in(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
    /**
     * Exclude specific room(s) or socket(s)
     */
    except(room: Room | Room[]): BroadcastOperator<EmitEvents, SocketData>;
    /**
     * Set compress flag
     */
    compress(compress: boolean): BroadcastOperator<EmitEvents, SocketData>;
    /**
     * Set volatile flag
     */
    get volatile(): BroadcastOperator<EmitEvents, SocketData>;
    /**
     * Set local flag
     */
    get local(): BroadcastOperator<EmitEvents, SocketData>;
    /**
     * Set timeout for acknowledgements
     */
    timeout(timeout: number): BroadcastOperator<DecorateAcknowledgements<EmitEvents>, SocketData>;
    /**
     * Set binary flag for forced binary protocol usage
     */
    get binary(): BroadcastOperator<EmitEvents, SocketData>;
    /**
     * Main emit method with full Socket.IO compatibility
     */
    emit<Ev extends EventNames<EmitEvents>>(ev: Ev, ...args: EventParams<EmitEvents, Ev>): boolean;
    /**
     * Emit with acknowledgement callback
     */
    emitWithAck<Ev extends EventNamesWithError<EmitEvents>>(ev: Ev, ...args: AllButLast<EventParams<EmitEvents, Ev>>): Promise<FirstNonErrorArg<Last<EventParams<EmitEvents, Ev>>>>;
    /**
     * Get all matching socket instances
     */
    fetchSockets(): Promise<Socket<EmitEvents, any, any, SocketData>[]>;
    /**
     * Make all matching sockets join room(s)
     */
    socketsJoin(room: Room | Room[]): void;
    /**
     * Make all matching sockets leave room(s)
     */
    socketsLeave(room: Room | Room[]): void;
    /**
     * Disconnect all matching sockets
     */
    disconnectSockets(close?: boolean): void;
}