cluster.d.ts (27958B)
1 /** 2 * Clusters of Node.js processes can be used to run multiple instances of Node.js 3 * that can distribute workloads among their application threads. When process isolation 4 * is not needed, use the [`worker_threads`](https://nodejs.org/docs/latest-v16.x/api/worker_threads.html) 5 * module instead, which allows running multiple application threads within a single Node.js instance. 6 * 7 * The cluster module allows easy creation of child processes that all share 8 * server ports. 9 * 10 * ```js 11 * import cluster from 'node:cluster'; 12 * import http from 'node:http'; 13 * import { cpus } from 'node:os'; 14 * import process from 'node:process'; 15 * 16 * const numCPUs = cpus().length; 17 * 18 * if (cluster.isPrimary) { 19 * console.log(`Primary ${process.pid} is running`); 20 * 21 * // Fork workers. 22 * for (let i = 0; i < numCPUs; i++) { 23 * cluster.fork(); 24 * } 25 * 26 * cluster.on('exit', (worker, code, signal) => { 27 * console.log(`worker ${worker.process.pid} died`); 28 * }); 29 * } else { 30 * // Workers can share any TCP connection 31 * // In this case it is an HTTP server 32 * http.createServer((req, res) => { 33 * res.writeHead(200); 34 * res.end('hello world\n'); 35 * }).listen(8000); 36 * 37 * console.log(`Worker ${process.pid} started`); 38 * } 39 * ``` 40 * 41 * Running Node.js will now share port 8000 between the workers: 42 * 43 * ```console 44 * $ node server.js 45 * Primary 3596 is running 46 * Worker 4324 started 47 * Worker 4520 started 48 * Worker 6056 started 49 * Worker 5644 started 50 * ``` 51 * 52 * On Windows, it is not yet possible to set up a named pipe server in a worker. 53 * @see [source](https://github.com/nodejs/node/blob/v16.20.2/lib/cluster.js) 54 */ 55 declare module "cluster" { 56 import * as child from "node:child_process"; 57 import EventEmitter = require("node:events"); 58 import * as net from "node:net"; 59 type SerializationType = "json" | "advanced"; 60 export interface ClusterSettings { 61 /** 62 * List of string arguments passed to the Node.js executable. 63 * @default process.execArgv 64 */ 65 execArgv?: string[] | undefined; 66 /** 67 * File path to worker file. 68 * @default process.argv[1] 69 */ 70 exec?: string | undefined; 71 /** 72 * String arguments passed to worker. 73 * @default process.argv.slice(2) 74 */ 75 args?: string[] | undefined; 76 /** 77 * Whether or not to send output to parent's stdio. 78 * @default false 79 */ 80 silent?: boolean | undefined; 81 /** 82 * Configures the stdio of forked processes. Because the cluster module relies on IPC to function, this configuration must 83 * contain an `'ipc'` entry. When this option is provided, it overrides `silent`. See [`child_prcess.spawn()`](https://nodejs.org/docs/latest-v16.x/api/child_process.html#child_processspawncommand-args-options)'s 84 * [`stdio`](https://nodejs.org/docs/latest-v16.x/api/child_process.html#optionsstdio). 85 */ 86 stdio?: any[] | undefined; 87 /** 88 * Sets the user identity of the process. (See [`setuid(2)`](https://man7.org/linux/man-pages/man2/setuid.2.html).) 89 */ 90 uid?: number | undefined; 91 /** 92 * Sets the group identity of the process. (See [`setgid(2)`](https://man7.org/linux/man-pages/man2/setgid.2.html).) 93 */ 94 gid?: number | undefined; 95 /** 96 * Sets inspector port of worker. This can be a number, or a function that takes no arguments and returns a number. 97 * By default each worker gets its own port, incremented from the primary's `process.debugPort`. 98 */ 99 inspectPort?: number | (() => number) | undefined; 100 /** 101 * Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`. 102 * See [Advanced serialization for `child_process`](https://nodejs.org/docs/latest-v16.x/api/child_process.html#advanced-serialization) for more details. 103 * @default false 104 */ 105 serialization?: SerializationType | undefined; 106 /** 107 * Current working directory of the worker process. 108 * @default undefined (inherits from parent process) 109 */ 110 cwd?: string | undefined; 111 /** 112 * Hide the forked processes console window that would normally be created on Windows systems. 113 * @default false 114 */ 115 windowsHide?: boolean | undefined; 116 } 117 export interface Address { 118 address: string; 119 port: number; 120 /** 121 * The `addressType` is one of: 122 * 123 * * `4` (TCPv4) 124 * * `6` (TCPv6) 125 * * `-1` (Unix domain socket) 126 * * `'udp4'` or `'udp6'` (UDPv4 or UDPv6) 127 */ 128 addressType: 4 | 6 | -1 | "udp4" | "udp6"; 129 } 130 /** 131 * A `Worker` object contains all public information and method about a worker. 132 * In the primary it can be obtained using `cluster.workers`. In a worker 133 * it can be obtained using `cluster.worker`. 134 * @since v0.7.0 135 */ 136 export class Worker extends EventEmitter { 137 /** 138 * Each new worker is given its own unique id, this id is stored in the `id`. 139 * 140 * While a worker is alive, this is the key that indexes it in `cluster.workers`. 141 * @since v0.8.0 142 */ 143 id: number; 144 /** 145 * All workers are created using [`child_process.fork()`](https://nodejs.org/docs/latest-v16.x/api/child_process.html#child_processforkmodulepath-args-options), the returned object 146 * from this function is stored as `.process`. In a worker, the global `process` is stored. 147 * 148 * See: [Child Process module](https://nodejs.org/docs/latest-v16.x/api/child_process.html#child_processforkmodulepath-args-options). 149 * 150 * Workers will call `process.exit(0)` if the `'disconnect'` event occurs 151 * on `process` and `.exitedAfterDisconnect` is not `true`. This protects against 152 * accidental disconnection. 153 * @since v0.7.0 154 */ 155 process: child.ChildProcess; 156 /** 157 * Send a message to a worker or primary, optionally with a handle. 158 * 159 * In the primary, this sends a message to a specific worker. It is identical to [`ChildProcess.send()`](https://nodejs.org/docs/latest-v16.x/api/child_process.html#subprocesssendmessage-sendhandle-options-callback). 160 * 161 * In a worker, this sends a message to the primary. It is identical to `process.send()`. 162 * 163 * This example will echo back all messages from the primary: 164 * 165 * ```js 166 * if (cluster.isPrimary) { 167 * const worker = cluster.fork(); 168 * worker.send('hi there'); 169 * 170 * } else if (cluster.isWorker) { 171 * process.on('message', (msg) => { 172 * process.send(msg); 173 * }); 174 * } 175 * ``` 176 * @since v0.7.0 177 * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles. 178 */ 179 send(message: child.Serializable, callback?: (error: Error | null) => void): boolean; 180 send( 181 message: child.Serializable, 182 sendHandle: child.SendHandle, 183 callback?: (error: Error | null) => void, 184 ): boolean; 185 send( 186 message: child.Serializable, 187 sendHandle: child.SendHandle, 188 options?: child.MessageOptions, 189 callback?: (error: Error | null) => void, 190 ): boolean; 191 /** 192 * This function will kill the worker. In the primary worker, it does this by 193 * disconnecting the `worker.process`, and once disconnected, killing with `signal`. In the worker, it does it by killing the process with `signal`. 194 * 195 * The `kill()` function kills the worker process without waiting for a graceful 196 * disconnect, it has the same behavior as `worker.process.kill()`. 197 * 198 * This method is aliased as `worker.destroy()` for backwards compatibility. 199 * 200 * In a worker, `process.kill()` exists, but it is not this function; 201 * it is [`kill()`](https://nodejs.org/docs/latest-v16.x/api/process.html#processkillpid-signal). 202 * @since v0.9.12 203 * @param [signal='SIGTERM'] Name of the kill signal to send to the worker process. 204 */ 205 kill(signal?: string): void; 206 destroy(signal?: string): void; 207 /** 208 * In a worker, this function will close all servers, wait for the `'close'` event 209 * on those servers, and then disconnect the IPC channel. 210 * 211 * In the primary, an internal message is sent to the worker causing it to call `.disconnect()` on itself. 212 * 213 * Causes `.exitedAfterDisconnect` to be set. 214 * 215 * After a server is closed, it will no longer accept new connections, 216 * but connections may be accepted by any other listening worker. Existing 217 * connections will be allowed to close as usual. When no more connections exist, 218 * see `server.close()`, the IPC channel to the worker will close allowing it 219 * to die gracefully. 220 * 221 * The above applies _only_ to server connections, client connections are not 222 * automatically closed by workers, and disconnect does not wait for them to close 223 * before exiting. 224 * 225 * In a worker, `process.disconnect` exists, but it is not this function; 226 * it is `disconnect()`. 227 * 228 * Because long living server connections may block workers from disconnecting, it 229 * may be useful to send a message, so application specific actions may be taken to 230 * close them. It also may be useful to implement a timeout, killing a worker if 231 * the `'disconnect'` event has not been emitted after some time. 232 * 233 * ```js 234 * import net from 'node:net'; 235 * if (cluster.isPrimary) { 236 * const worker = cluster.fork(); 237 * let timeout; 238 * 239 * worker.on('listening', (address) => { 240 * worker.send('shutdown'); 241 * worker.disconnect(); 242 * timeout = setTimeout(() => { 243 * worker.kill(); 244 * }, 2000); 245 * }); 246 * 247 * worker.on('disconnect', () => { 248 * clearTimeout(timeout); 249 * }); 250 * 251 * } else if (cluster.isWorker) { 252 * const server = net.createServer((socket) => { 253 * // Connections never end 254 * }); 255 * 256 * server.listen(8000); 257 * 258 * process.on('message', (msg) => { 259 * if (msg === 'shutdown') { 260 * // Initiate graceful close of any connections to server 261 * } 262 * }); 263 * } 264 * ``` 265 * @since v0.7.7 266 * @return A reference to `worker`. 267 */ 268 disconnect(): void; 269 /** 270 * This function returns `true` if the worker is connected to its primary via its 271 * IPC channel, `false` otherwise. A worker is connected to its primary after it 272 * has been created. It is disconnected after the `'disconnect'` event is emitted. 273 * @since v0.11.14 274 */ 275 isConnected(): boolean; 276 /** 277 * This function returns `true` if the worker's process has terminated (either 278 * because of exiting or being signaled). Otherwise, it returns `false`. 279 * 280 * ```js 281 * import cluster from 'node:cluster'; 282 * import http from 'node:http'; 283 * import { cpus } from 'node:os'; 284 * import process from 'node:process'; 285 * 286 * const numCPUs = cpus().length; 287 * 288 * if (cluster.isPrimary) { 289 * console.log(`Primary ${process.pid} is running`); 290 * 291 * // Fork workers. 292 * for (let i = 0; i < numCPUs; i++) { 293 * cluster.fork(); 294 * } 295 * 296 * cluster.on('fork', (worker) => { 297 * console.log('worker is dead:', worker.isDead()); 298 * }); 299 * 300 * cluster.on('exit', (worker, code, signal) => { 301 * console.log('worker is dead:', worker.isDead()); 302 * }); 303 * } else { 304 * // Workers can share any TCP connection. In this case, it is an HTTP server. 305 * http.createServer((req, res) => { 306 * res.writeHead(200); 307 * res.end(`Current process\n ${process.pid}`); 308 * process.kill(process.pid); 309 * }).listen(8000); 310 * } 311 * ``` 312 * @since v0.11.14 313 */ 314 isDead(): boolean; 315 /** 316 * This property is `true` if the worker exited due to `.disconnect()`. 317 * If the worker exited any other way, it is `false`. If the 318 * worker has not exited, it is `undefined`. 319 * 320 * The boolean `worker.exitedAfterDisconnect` allows distinguishing between 321 * voluntary and accidental exit, the primary may choose not to respawn a worker 322 * based on this value. 323 * 324 * ```js 325 * cluster.on('exit', (worker, code, signal) => { 326 * if (worker.exitedAfterDisconnect === true) { 327 * console.log('Oh, it was just voluntary – no need to worry'); 328 * } 329 * }); 330 * 331 * // kill worker 332 * worker.kill(); 333 * ``` 334 * @since v6.0.0 335 */ 336 exitedAfterDisconnect: boolean; 337 /** 338 * events.EventEmitter 339 * 1. disconnect 340 * 2. error 341 * 3. exit 342 * 4. listening 343 * 5. message 344 * 6. online 345 */ 346 addListener(event: string, listener: (...args: any[]) => void): this; 347 addListener(event: "disconnect", listener: () => void): this; 348 addListener(event: "error", listener: (error: Error) => void): this; 349 addListener(event: "exit", listener: (code: number, signal: string) => void): this; 350 addListener(event: "listening", listener: (address: Address) => void): this; 351 addListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined. 352 addListener(event: "online", listener: () => void): this; 353 emit(event: string | symbol, ...args: any[]): boolean; 354 emit(event: "disconnect"): boolean; 355 emit(event: "error", error: Error): boolean; 356 emit(event: "exit", code: number, signal: string): boolean; 357 emit(event: "listening", address: Address): boolean; 358 emit(event: "message", message: any, handle: net.Socket | net.Server): boolean; 359 emit(event: "online"): boolean; 360 on(event: string, listener: (...args: any[]) => void): this; 361 on(event: "disconnect", listener: () => void): this; 362 on(event: "error", listener: (error: Error) => void): this; 363 on(event: "exit", listener: (code: number, signal: string) => void): this; 364 on(event: "listening", listener: (address: Address) => void): this; 365 on(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined. 366 on(event: "online", listener: () => void): this; 367 once(event: string, listener: (...args: any[]) => void): this; 368 once(event: "disconnect", listener: () => void): this; 369 once(event: "error", listener: (error: Error) => void): this; 370 once(event: "exit", listener: (code: number, signal: string) => void): this; 371 once(event: "listening", listener: (address: Address) => void): this; 372 once(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined. 373 once(event: "online", listener: () => void): this; 374 prependListener(event: string, listener: (...args: any[]) => void): this; 375 prependListener(event: "disconnect", listener: () => void): this; 376 prependListener(event: "error", listener: (error: Error) => void): this; 377 prependListener(event: "exit", listener: (code: number, signal: string) => void): this; 378 prependListener(event: "listening", listener: (address: Address) => void): this; 379 prependListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined. 380 prependListener(event: "online", listener: () => void): this; 381 prependOnceListener(event: string, listener: (...args: any[]) => void): this; 382 prependOnceListener(event: "disconnect", listener: () => void): this; 383 prependOnceListener(event: "error", listener: (error: Error) => void): this; 384 prependOnceListener(event: "exit", listener: (code: number, signal: string) => void): this; 385 prependOnceListener(event: "listening", listener: (address: Address) => void): this; 386 prependOnceListener(event: "message", listener: (message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined. 387 prependOnceListener(event: "online", listener: () => void): this; 388 } 389 export interface Cluster extends EventEmitter { 390 disconnect(callback?: () => void): void; 391 /** 392 * Spawn a new worker process. 393 * 394 * This can only be called from the primary process. 395 * @param env Key/value pairs to add to worker process environment. 396 * @since v0.6.0 397 */ 398 fork(env?: any): Worker; 399 /** @deprecated since v16.0.0 - use isPrimary. */ 400 readonly isMaster: boolean; 401 /** 402 * True if the process is a primary. This is determined by the `process.env.NODE_UNIQUE_ID`. If `process.env.NODE_UNIQUE_ID` 403 * is undefined, then `isPrimary` is `true`. 404 * @since v16.0.0 405 */ 406 readonly isPrimary: boolean; 407 /** 408 * True if the process is not a primary (it is the negation of `cluster.isPrimary`). 409 * @since v0.6.0 410 */ 411 readonly isWorker: boolean; 412 /** 413 * The scheduling policy, either `cluster.SCHED_RR` for round-robin or `cluster.SCHED_NONE` to leave it to the operating system. This is a 414 * global setting and effectively frozen once either the first worker is spawned, or [`.setupPrimary()`](https://nodejs.org/docs/latest-v16.x/api/cluster.html#clustersetupprimarysettings) 415 * is called, whichever comes first. 416 * 417 * `SCHED_RR` is the default on all operating systems except Windows. Windows will change to `SCHED_RR` once libuv is able to effectively distribute 418 * IOCP handles without incurring a large performance hit. 419 * 420 * `cluster.schedulingPolicy` can also be set through the `NODE_CLUSTER_SCHED_POLICY` environment variable. Valid values are `'rr'` and `'none'`. 421 * @since v0.11.2 422 */ 423 schedulingPolicy: number; 424 /** 425 * After calling [`.setupPrimary()`](https://nodejs.org/docs/latest-v16.x/api/cluster.html#clustersetupprimarysettings) 426 * (or [`.fork()`](https://nodejs.org/docs/latest-v16.x/api/cluster.html#clusterforkenv)) this settings object will contain 427 * the settings, including the default values. 428 * 429 * This object is not intended to be changed or set manually. 430 * @since v0.7.1 431 */ 432 readonly settings: ClusterSettings; 433 /** @deprecated since v16.0.0 - use [`.setupPrimary()`](https://nodejs.org/docs/latest-v16.x/api/cluster.html#clustersetupprimarysettings) instead. */ 434 setupMaster(settings?: ClusterSettings): void; 435 /** 436 * `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in `cluster.settings`. 437 * 438 * Any settings changes only affect future calls to [`.fork()`](https://nodejs.org/docs/latest-v16.x/api/cluster.html#clusterforkenv) 439 * and have no effect on workers that are already running. 440 * 441 * The only attribute of a worker that cannot be set via `.setupPrimary()` is the `env` passed to 442 * [`.fork()`](https://nodejs.org/docs/latest-v16.x/api/cluster.html#clusterforkenv). 443 * 444 * The defaults above apply to the first call only; the defaults for later calls are the current values at the time of 445 * `cluster.setupPrimary()` is called. 446 * 447 * ```js 448 * import cluster from 'node:cluster'; 449 * 450 * cluster.setupPrimary({ 451 * exec: 'worker.js', 452 * args: ['--use', 'https'], 453 * silent: true, 454 * }); 455 * cluster.fork(); // https worker 456 * cluster.setupPrimary({ 457 * exec: 'worker.js', 458 * args: ['--use', 'http'], 459 * }); 460 * cluster.fork(); // http worker 461 * ``` 462 * 463 * This can only be called from the primary process. 464 * @since v16.0.0 465 */ 466 setupPrimary(settings?: ClusterSettings): void; 467 /** 468 * A reference to the current worker object. Not available in the primary process. 469 * 470 * ```js 471 * import cluster from 'node:cluster'; 472 * 473 * if (cluster.isPrimary) { 474 * console.log('I am primary'); 475 * cluster.fork(); 476 * cluster.fork(); 477 * } else if (cluster.isWorker) { 478 * console.log(`I am worker #${cluster.worker.id}`); 479 * } 480 * ``` 481 * @since v0.7.0 482 */ 483 readonly worker?: Worker | undefined; 484 /** 485 * A hash that stores the active worker objects, keyed by `id` field. This makes it easy to loop through all the workers. It is only available in the primary process. 486 * 487 * A worker is removed from `cluster.workers` after the worker has disconnected _and_ exited. The order between these two events cannot be determined in advance. However, it 488 * is guaranteed that the removal from the `cluster.workers` list happens before the last `'disconnect'` or `'exit'` event is emitted. 489 * 490 * ```js 491 * import cluster from 'node:cluster'; 492 * 493 * for (const worker of Object.values(cluster.workers)) { 494 * worker.send('big announcement to all workers'); 495 * } 496 * ``` 497 * @since v0.7.0 498 */ 499 readonly workers?: NodeJS.Dict<Worker> | undefined; 500 readonly SCHED_NONE: number; 501 readonly SCHED_RR: number; 502 /** 503 * events.EventEmitter 504 * 1. disconnect 505 * 2. exit 506 * 3. fork 507 * 4. listening 508 * 5. message 509 * 6. online 510 * 7. setup 511 */ 512 addListener(event: string, listener: (...args: any[]) => void): this; 513 addListener(event: "disconnect", listener: (worker: Worker) => void): this; 514 addListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this; 515 addListener(event: "fork", listener: (worker: Worker) => void): this; 516 addListener(event: "listening", listener: (worker: Worker, address: Address) => void): this; 517 addListener( 518 event: "message", 519 listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void, 520 ): this; // the handle is a net.Socket or net.Server object, or undefined. 521 addListener(event: "online", listener: (worker: Worker) => void): this; 522 addListener(event: "setup", listener: (settings: ClusterSettings) => void): this; 523 emit(event: string | symbol, ...args: any[]): boolean; 524 emit(event: "disconnect", worker: Worker): boolean; 525 emit(event: "exit", worker: Worker, code: number, signal: string): boolean; 526 emit(event: "fork", worker: Worker): boolean; 527 emit(event: "listening", worker: Worker, address: Address): boolean; 528 emit(event: "message", worker: Worker, message: any, handle: net.Socket | net.Server): boolean; 529 emit(event: "online", worker: Worker): boolean; 530 emit(event: "setup", settings: ClusterSettings): boolean; 531 on(event: string, listener: (...args: any[]) => void): this; 532 on(event: "disconnect", listener: (worker: Worker) => void): this; 533 on(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this; 534 on(event: "fork", listener: (worker: Worker) => void): this; 535 on(event: "listening", listener: (worker: Worker, address: Address) => void): this; 536 on(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined. 537 on(event: "online", listener: (worker: Worker) => void): this; 538 on(event: "setup", listener: (settings: ClusterSettings) => void): this; 539 once(event: string, listener: (...args: any[]) => void): this; 540 once(event: "disconnect", listener: (worker: Worker) => void): this; 541 once(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this; 542 once(event: "fork", listener: (worker: Worker) => void): this; 543 once(event: "listening", listener: (worker: Worker, address: Address) => void): this; 544 once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined. 545 once(event: "online", listener: (worker: Worker) => void): this; 546 once(event: "setup", listener: (settings: ClusterSettings) => void): this; 547 prependListener(event: string, listener: (...args: any[]) => void): this; 548 prependListener(event: "disconnect", listener: (worker: Worker) => void): this; 549 prependListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this; 550 prependListener(event: "fork", listener: (worker: Worker) => void): this; 551 prependListener(event: "listening", listener: (worker: Worker, address: Address) => void): this; 552 // the handle is a net.Socket or net.Server object, or undefined. 553 prependListener( 554 event: "message", 555 listener: (worker: Worker, message: any, handle?: net.Socket | net.Server) => void, 556 ): this; 557 prependListener(event: "online", listener: (worker: Worker) => void): this; 558 prependListener(event: "setup", listener: (settings: ClusterSettings) => void): this; 559 prependOnceListener(event: string, listener: (...args: any[]) => void): this; 560 prependOnceListener(event: "disconnect", listener: (worker: Worker) => void): this; 561 prependOnceListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this; 562 prependOnceListener(event: "fork", listener: (worker: Worker) => void): this; 563 prependOnceListener(event: "listening", listener: (worker: Worker, address: Address) => void): this; 564 // the handle is a net.Socket or net.Server object, or undefined. 565 prependOnceListener( 566 event: "message", 567 listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void, 568 ): this; 569 prependOnceListener(event: "online", listener: (worker: Worker) => void): this; 570 prependOnceListener(event: "setup", listener: (settings: ClusterSettings) => void): this; 571 } 572 const cluster: Cluster; 573 export default cluster; 574 } 575 declare module "node:cluster" { 576 export * from "cluster"; 577 export { default as default } from "cluster"; 578 }