import type { BroadcastFlags, Room, SocketId } from "socket.io-adapter"; import { Handshake } from "./socket-types"; import type { Adapter } from "socket.io-adapter"; import type { EventParams, EventNames, EventsMap, TypedEventBroadcaster, DecorateAcknowledgements, AllButLast, Last, FirstNonErrorArg, EventNamesWithError } from "./typed-events"; export declare class BroadcastOperator implements TypedEventBroadcaster { private readonly adapter; private readonly rooms; private readonly exceptRooms; private readonly flags; constructor(adapter: Adapter, rooms?: Set, exceptRooms?: Set, flags?: BroadcastFlags & { expectSingleResponse?: boolean; }); /** * Targets a room when emitting. * * @example * // the “foo” event will be broadcast to all connected clients in the “room-101” room * io.to("room-101").emit("foo", "bar"); * * // with an array of rooms (a client will be notified at most once) * io.to(["room-101", "room-102"]).emit("foo", "bar"); * * // with multiple chained calls * io.to("room-101").to("room-102").emit("foo", "bar"); * * @param room - a room, or an array of rooms * @return a new {@link BroadcastOperator} instance for chaining */ to(room: Room | Room[]): BroadcastOperator; /** * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases: * * @example * // disconnect all clients in the "room-101" room * io.in("room-101").disconnectSockets(); * * @param room - a room, or an array of rooms * @return a new {@link BroadcastOperator} instance for chaining */ in(room: Room | Room[]): BroadcastOperator; /** * Excludes a room when emitting. * * @example * // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room * io.except("room-101").emit("foo", "bar"); * * // with an array of rooms * io.except(["room-101", "room-102"]).emit("foo", "bar"); * * // with multiple chained calls * io.except("room-101").except("room-102").emit("foo", "bar"); * * @param room - a room, or an array of rooms * @return a new {@link BroadcastOperator} instance for chaining */ except(room: Room | Room[]): BroadcastOperator; /** * Sets the compress flag. * * @example * io.compress(false).emit("hello"); * * @param compress - if `true`, compresses the sending data * @return a new BroadcastOperator instance */ compress(compress: boolean): BroadcastOperator; /** * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to * receive messages (because of network slowness or other issues, or because they’re connected through long polling * and is in the middle of a request-response cycle). * * @example * io.volatile.emit("hello"); // the clients may or may not receive it * * @return a new BroadcastOperator instance */ get volatile(): BroadcastOperator; /** * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. * * @example * // the “foo” event will be broadcast to all connected clients on this node * io.local.emit("foo", "bar"); * * @return a new {@link BroadcastOperator} instance for chaining */ get local(): BroadcastOperator; /** * Adds a timeout in milliseconds for the next operation * * @example * io.timeout(1000).emit("some-event", (err, responses) => { * if (err) { * // some clients did not acknowledge the event in the given delay * } else { * console.log(responses); // one response per client * } * }); * * @param timeout */ timeout(timeout: number): BroadcastOperator, SocketData>; /** * Emits to all clients. * * @example * // the “foo” event will be broadcast to all connected clients * io.emit("foo", "bar"); * * // the “foo” event will be broadcast to all connected clients in the “room-101” room * io.to("room-101").emit("foo", "bar"); * * // with an acknowledgement expected from all connected clients * io.timeout(1000).emit("some-event", (err, responses) => { * if (err) { * // some clients did not acknowledge the event in the given delay * } else { * console.log(responses); // one response per client * } * }); * * @return Always true */ emit>(ev: Ev, ...args: EventParams): boolean; /** * Emits an event and waits for an acknowledgement from all clients. * * @example * try { * const responses = await io.timeout(1000).emitWithAck("some-event"); * console.log(responses); // one response per client * } catch (e) { * // some clients did not acknowledge the event in the given delay * } * * @return a Promise that will be fulfilled when all clients have acknowledged the event */ emitWithAck>(ev: Ev, ...args: AllButLast>): Promise>>>; /** * Gets a list of clients. * * @deprecated this method will be removed in the next major release, please use {@link Server#serverSideEmit} or * {@link fetchSockets} instead. */ allSockets(): Promise>; /** * Returns the matching socket instances. This method works across a cluster of several Socket.IO servers. * * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}. * * @example * // return all Socket instances * const sockets = await io.fetchSockets(); * * // return all Socket instances in the "room1" room * const sockets = await io.in("room1").fetchSockets(); * * for (const socket of sockets) { * console.log(socket.id); * console.log(socket.handshake); * console.log(socket.rooms); * console.log(socket.data); * * socket.emit("hello"); * socket.join("room1"); * socket.leave("room2"); * socket.disconnect(); * } */ fetchSockets(): Promise[]>; /** * Makes the matching socket instances join the specified rooms. * * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}. * * @example * * // make all socket instances join the "room1" room * io.socketsJoin("room1"); * * // make all socket instances in the "room1" room join the "room2" and "room3" rooms * io.in("room1").socketsJoin(["room2", "room3"]); * * @param room - a room, or an array of rooms */ socketsJoin(room: Room | Room[]): void; /** * Makes the matching socket instances leave the specified rooms. * * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}. * * @example * // make all socket instances leave the "room1" room * io.socketsLeave("room1"); * * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms * io.in("room1").socketsLeave(["room2", "room3"]); * * @param room - a room, or an array of rooms */ socketsLeave(room: Room | Room[]): void; /** * Makes the matching socket instances disconnect. * * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}. * * @example * // make all socket instances disconnect (the connections might be kept alive for other namespaces) * io.disconnectSockets(); * * // make all socket instances in the "room1" room disconnect and close the underlying connections * io.in("room1").disconnectSockets(true); * * @param close - whether to close the underlying connection */ disconnectSockets(close?: boolean): void; } /** * Format of the data when the Socket instance exists on another Socket.IO server */ interface SocketDetails { id: SocketId; handshake: Handshake; rooms: Room[]; data: SocketData; } /** * Expose of subset of the attributes and methods of the Socket class */ export declare class RemoteSocket implements TypedEventBroadcaster { readonly id: SocketId; readonly handshake: Handshake; readonly rooms: Set; readonly data: SocketData; private readonly operator; constructor(adapter: Adapter, details: SocketDetails); /** * Adds a timeout in milliseconds for the next operation. * * @example * const sockets = await io.fetchSockets(); * * for (const socket of sockets) { * if (someCondition) { * socket.timeout(1000).emit("some-event", (err) => { * if (err) { * // the client did not acknowledge the event in the given delay * } * }); * } * } * * // note: if possible, using a room instead of looping over all sockets is preferable * io.timeout(1000).to(someConditionRoom).emit("some-event", (err, responses) => { * // ... * }); * * @param timeout */ timeout(timeout: number): BroadcastOperator, SocketData>; emit>(ev: Ev, ...args: EventParams): boolean; /** * Joins a room. * * @param {String|Array} room - room or array of rooms */ join(room: Room | Room[]): void; /** * Leaves a room. * * @param {String} room */ leave(room: Room): void; /** * Disconnects this client. * * @param {Boolean} close - if `true`, closes the underlying connection * @return {Socket} self */ disconnect(close?: boolean): this; } export {};