@codingame/monaco-editor-wrapper 18.0.0 → 18.0.2

package/dist/_virtual/typescript-worker-node-types.js

@@ -55,10 +55,10 @@ var typescriptWorkerNodeTypes = {
 	"stream/consumers.d.ts": "declare module \"stream/consumers\" {\n    import { Readable } from \"node:stream\";\n    import { Blob as NodeBlob } from \"node:buffer\";\n    function buffer(stream: NodeJS.ReadableStream | Readable | AsyncIterable<any>): Promise<Buffer>;\n    function text(stream: NodeJS.ReadableStream | Readable | AsyncIterable<any>): Promise<string>;\n    function arrayBuffer(stream: NodeJS.ReadableStream | Readable | AsyncIterable<any>): Promise<ArrayBuffer>;\n    function blob(stream: NodeJS.ReadableStream | Readable | AsyncIterable<any>): Promise<NodeBlob>;\n    function json(stream: NodeJS.ReadableStream | Readable | AsyncIterable<any>): Promise<unknown>;\n}\ndeclare module \"node:stream/consumers\" {\n    export * from \"stream/consumers\";\n}\n",
 	"stream/promises.d.ts": "declare module \"stream/promises\" {\n    import {\n        FinishedOptions,\n        PipelineDestination,\n        PipelineOptions,\n        PipelinePromise,\n        PipelineSource,\n        PipelineTransform,\n    } from \"node:stream\";\n    function finished(\n        stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,\n        options?: FinishedOptions,\n    ): Promise<void>;\n    function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(\n        source: A,\n        destination: B,\n        options?: PipelineOptions,\n    ): PipelinePromise<B>;\n    function pipeline<\n        A extends PipelineSource<any>,\n        T1 extends PipelineTransform<A, any>,\n        B extends PipelineDestination<T1, any>,\n    >(\n        source: A,\n        transform1: T1,\n        destination: B,\n        options?: PipelineOptions,\n    ): PipelinePromise<B>;\n    function pipeline<\n        A extends PipelineSource<any>,\n        T1 extends PipelineTransform<A, any>,\n        T2 extends PipelineTransform<T1, any>,\n        B extends PipelineDestination<T2, any>,\n    >(\n        source: A,\n        transform1: T1,\n        transform2: T2,\n        destination: B,\n        options?: PipelineOptions,\n    ): PipelinePromise<B>;\n    function pipeline<\n        A extends PipelineSource<any>,\n        T1 extends PipelineTransform<A, any>,\n        T2 extends PipelineTransform<T1, any>,\n        T3 extends PipelineTransform<T2, any>,\n        B extends PipelineDestination<T3, any>,\n    >(\n        source: A,\n        transform1: T1,\n        transform2: T2,\n        transform3: T3,\n        destination: B,\n        options?: PipelineOptions,\n    ): PipelinePromise<B>;\n    function pipeline<\n        A extends PipelineSource<any>,\n        T1 extends PipelineTransform<A, any>,\n        T2 extends PipelineTransform<T1, any>,\n        T3 extends PipelineTransform<T2, any>,\n        T4 extends PipelineTransform<T3, any>,\n        B extends PipelineDestination<T4, any>,\n    >(\n        source: A,\n        transform1: T1,\n        transform2: T2,\n        transform3: T3,\n        transform4: T4,\n        destination: B,\n        options?: PipelineOptions,\n    ): PipelinePromise<B>;\n    function pipeline(\n        streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,\n        options?: PipelineOptions,\n    ): Promise<void>;\n    function pipeline(\n        stream1: NodeJS.ReadableStream,\n        stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,\n        ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>\n    ): Promise<void>;\n}\ndeclare module \"node:stream/promises\" {\n    export * from \"stream/promises\";\n}\n",
 	"stream/web.d.ts": "declare module \"stream/web\" {\n    // stub module, pending copy&paste from .d.ts or manual impl\n    // copy from lib.dom.d.ts\n\n    interface ReadableWritablePair<R = any, W = any> {\n        readable: ReadableStream<R>;\n        /**\n         * Provides a convenient, chainable way of piping this readable stream\n         * through a transform stream (or any other { writable, readable }\n         * pair). It simply pipes the stream into the writable side of the\n         * supplied pair, and returns the readable side for further use.\n         *\n         * Piping a stream will lock it for the duration of the pipe, preventing\n         * any other consumer from acquiring a reader.\n         */\n        writable: WritableStream<W>;\n    }\n\n    interface StreamPipeOptions {\n        preventAbort?: boolean;\n        preventCancel?: boolean;\n        /**\n         * Pipes this readable stream to a given writable stream destination.\n         * The way in which the piping process behaves under various error\n         * conditions can be customized with a number of passed options. It\n         * returns a promise that fulfills when the piping process completes\n         * successfully, or rejects if any errors were encountered.\n         *\n         * Piping a stream will lock it for the duration of the pipe, preventing\n         * any other consumer from acquiring a reader.\n         *\n         * Errors and closures of the source and destination streams propagate\n         * as follows:\n         *\n         * An error in this source readable stream will abort destination,\n         * unless preventAbort is truthy. The returned promise will be rejected\n         * with the source's error, or with any error that occurs during\n         * aborting the destination.\n         *\n         * An error in destination will cancel this source readable stream,\n         * unless preventCancel is truthy. The returned promise will be rejected\n         * with the destination's error, or with any error that occurs during\n         * canceling the source.\n         *\n         * When this source readable stream closes, destination will be closed,\n         * unless preventClose is truthy. The returned promise will be fulfilled\n         * once this process completes, unless an error is encountered while\n         * closing the destination, in which case it will be rejected with that\n         * error.\n         *\n         * If destination starts out closed or closing, this source readable\n         * stream will be canceled, unless preventCancel is true. The returned\n         * promise will be rejected with an error indicating piping to a closed\n         * stream failed, or with any error that occurs during canceling the\n         * source.\n         *\n         * The signal option can be set to an AbortSignal to allow aborting an\n         * ongoing pipe operation via the corresponding AbortController. In this\n         * case, this source readable stream will be canceled, and destination\n         * aborted, unless the respective options preventCancel or preventAbort\n         * are set.\n         */\n        preventClose?: boolean;\n        signal?: AbortSignal;\n    }\n\n    interface ReadableStreamGenericReader {\n        readonly closed: Promise<undefined>;\n        cancel(reason?: any): Promise<void>;\n    }\n\n    interface ReadableStreamDefaultReadValueResult<T> {\n        done: false;\n        value: T;\n    }\n\n    interface ReadableStreamDefaultReadDoneResult {\n        done: true;\n        value?: undefined;\n    }\n    type ReadableStreamController<T> = ReadableStreamDefaultController<T>;\n    type ReadableStreamDefaultReadResult<T> =\n        | ReadableStreamDefaultReadValueResult<T>\n        | ReadableStreamDefaultReadDoneResult;\n\n    interface ReadableByteStreamControllerCallback {\n        (controller: ReadableByteStreamController): void | PromiseLike<void>;\n    }\n\n    interface UnderlyingSinkAbortCallback {\n        (reason?: any): void | PromiseLike<void>;\n    }\n\n    interface UnderlyingSinkCloseCallback {\n        (): void | PromiseLike<void>;\n    }\n\n    interface UnderlyingSinkStartCallback {\n        (controller: WritableStreamDefaultController): any;\n    }\n\n    interface UnderlyingSinkWriteCallback<W> {\n        (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;\n    }\n\n    interface UnderlyingSourceCancelCallback {\n        (reason?: any): void | PromiseLike<void>;\n    }\n\n    interface UnderlyingSourcePullCallback<R> {\n        (controller: ReadableStreamController<R>): void | PromiseLike<void>;\n    }\n\n    interface UnderlyingSourceStartCallback<R> {\n        (controller: ReadableStreamController<R>): any;\n    }\n\n    interface TransformerFlushCallback<O> {\n        (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;\n    }\n\n    interface TransformerStartCallback<O> {\n        (controller: TransformStreamDefaultController<O>): any;\n    }\n\n    interface TransformerTransformCallback<I, O> {\n        (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;\n    }\n\n    interface UnderlyingByteSource {\n        autoAllocateChunkSize?: number;\n        cancel?: ReadableStreamErrorCallback;\n        pull?: ReadableByteStreamControllerCallback;\n        start?: ReadableByteStreamControllerCallback;\n        type: \"bytes\";\n    }\n\n    interface UnderlyingSource<R = any> {\n        cancel?: UnderlyingSourceCancelCallback;\n        pull?: UnderlyingSourcePullCallback<R>;\n        start?: UnderlyingSourceStartCallback<R>;\n        type?: undefined;\n    }\n\n    interface UnderlyingSink<W = any> {\n        abort?: UnderlyingSinkAbortCallback;\n        close?: UnderlyingSinkCloseCallback;\n        start?: UnderlyingSinkStartCallback;\n        type?: undefined;\n        write?: UnderlyingSinkWriteCallback<W>;\n    }\n\n    interface ReadableStreamErrorCallback {\n        (reason: any): void | PromiseLike<void>;\n    }\n\n    interface ReadableStreamAsyncIterator<T> extends NodeJS.AsyncIterator<T, NodeJS.BuiltinIteratorReturn, unknown> {\n        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;\n    }\n\n    /** This Streams API interface represents a readable stream of byte data. */\n    interface ReadableStream<R = any> {\n        readonly locked: boolean;\n        cancel(reason?: any): Promise<void>;\n        getReader(): ReadableStreamDefaultReader<R>;\n        pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;\n        pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;\n        tee(): [ReadableStream<R>, ReadableStream<R>];\n        values(options?: { preventCancel?: boolean }): ReadableStreamAsyncIterator<R>;\n        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<R>;\n    }\n\n    const ReadableStream: {\n        prototype: ReadableStream;\n        new(\n            underlyingSource: UnderlyingByteSource,\n            strategy?: QueuingStrategy<Uint8Array>,\n        ): ReadableStream<Uint8Array>;\n        new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;\n    };\n\n    interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {\n        read(): Promise<ReadableStreamDefaultReadResult<R>>;\n        releaseLock(): void;\n    }\n\n    const ReadableStreamDefaultReader: {\n        prototype: ReadableStreamDefaultReader;\n        new<R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;\n    };\n\n    const ReadableStreamBYOBReader: any;\n    const ReadableStreamBYOBRequest: any;\n\n    interface ReadableByteStreamController {\n        readonly byobRequest: undefined;\n        readonly desiredSize: number | null;\n        close(): void;\n        enqueue(chunk: ArrayBufferView): void;\n        error(error?: any): void;\n    }\n\n    const ReadableByteStreamController: {\n        prototype: ReadableByteStreamController;\n        new(): ReadableByteStreamController;\n    };\n\n    interface ReadableStreamDefaultController<R = any> {\n        readonly desiredSize: number | null;\n        close(): void;\n        enqueue(chunk?: R): void;\n        error(e?: any): void;\n    }\n\n    const ReadableStreamDefaultController: {\n        prototype: ReadableStreamDefaultController;\n        new(): ReadableStreamDefaultController;\n    };\n\n    interface Transformer<I = any, O = any> {\n        flush?: TransformerFlushCallback<O>;\n        readableType?: undefined;\n        start?: TransformerStartCallback<O>;\n        transform?: TransformerTransformCallback<I, O>;\n        writableType?: undefined;\n    }\n\n    interface TransformStream<I = any, O = any> {\n        readonly readable: ReadableStream<O>;\n        readonly writable: WritableStream<I>;\n    }\n\n    const TransformStream: {\n        prototype: TransformStream;\n        new<I = any, O = any>(\n            transformer?: Transformer<I, O>,\n            writableStrategy?: QueuingStrategy<I>,\n            readableStrategy?: QueuingStrategy<O>,\n        ): TransformStream<I, O>;\n    };\n\n    interface TransformStreamDefaultController<O = any> {\n        readonly desiredSize: number | null;\n        enqueue(chunk?: O): void;\n        error(reason?: any): void;\n        terminate(): void;\n    }\n\n    const TransformStreamDefaultController: {\n        prototype: TransformStreamDefaultController;\n        new(): TransformStreamDefaultController;\n    };\n\n    /**\n     * This Streams API interface provides a standard abstraction for writing\n     * streaming data to a destination, known as a sink. This object comes with\n     * built-in back pressure and queuing.\n     */\n    interface WritableStream<W = any> {\n        readonly locked: boolean;\n        abort(reason?: any): Promise<void>;\n        close(): Promise<void>;\n        getWriter(): WritableStreamDefaultWriter<W>;\n    }\n\n    const WritableStream: {\n        prototype: WritableStream;\n        new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;\n    };\n\n    /**\n     * This Streams API interface is the object returned by\n     * WritableStream.getWriter() and once created locks the < writer to the\n     * WritableStream ensuring that no other streams can write to the underlying\n     * sink.\n     */\n    interface WritableStreamDefaultWriter<W = any> {\n        readonly closed: Promise<undefined>;\n        readonly desiredSize: number | null;\n        readonly ready: Promise<undefined>;\n        abort(reason?: any): Promise<void>;\n        close(): Promise<void>;\n        releaseLock(): void;\n        write(chunk?: W): Promise<void>;\n    }\n\n    const WritableStreamDefaultWriter: {\n        prototype: WritableStreamDefaultWriter;\n        new<W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;\n    };\n\n    /**\n     * This Streams API interface represents a controller allowing control of a\n     * WritableStream's state. When constructing a WritableStream, the\n     * underlying sink is given a corresponding WritableStreamDefaultController\n     * instance to manipulate.\n     */\n    interface WritableStreamDefaultController {\n        error(e?: any): void;\n    }\n\n    const WritableStreamDefaultController: {\n        prototype: WritableStreamDefaultController;\n        new(): WritableStreamDefaultController;\n    };\n\n    interface QueuingStrategy<T = any> {\n        highWaterMark?: number;\n        size?: QueuingStrategySize<T>;\n    }\n\n    interface QueuingStrategySize<T = any> {\n        (chunk?: T): number;\n    }\n\n    interface QueuingStrategyInit {\n        /**\n         * Creates a new ByteLengthQueuingStrategy with the provided high water\n         * mark.\n         *\n         * Note that the provided high water mark will not be validated ahead of\n         * time. Instead, if it is negative, NaN, or not a number, the resulting\n         * ByteLengthQueuingStrategy will cause the corresponding stream\n         * constructor to throw.\n         */\n        highWaterMark: number;\n    }\n\n    /**\n     * This Streams API interface provides a built-in byte length queuing\n     * strategy that can be used when constructing streams.\n     */\n    interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {\n        readonly highWaterMark: number;\n        readonly size: QueuingStrategySize<ArrayBufferView>;\n    }\n\n    const ByteLengthQueuingStrategy: {\n        prototype: ByteLengthQueuingStrategy;\n        new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;\n    };\n\n    /**\n     * This Streams API interface provides a built-in byte length queuing\n     * strategy that can be used when constructing streams.\n     */\n    interface CountQueuingStrategy extends QueuingStrategy {\n        readonly highWaterMark: number;\n        readonly size: QueuingStrategySize;\n    }\n\n    const CountQueuingStrategy: {\n        prototype: CountQueuingStrategy;\n        new(init: QueuingStrategyInit): CountQueuingStrategy;\n    };\n\n    interface TextEncoderStream {\n        /** Returns \"utf-8\". */\n        readonly encoding: \"utf-8\";\n        readonly readable: ReadableStream<Uint8Array>;\n        readonly writable: WritableStream<string>;\n        readonly [Symbol.toStringTag]: string;\n    }\n\n    const TextEncoderStream: {\n        prototype: TextEncoderStream;\n        new(): TextEncoderStream;\n    };\n\n    interface TextDecoderOptions {\n        fatal?: boolean;\n        ignoreBOM?: boolean;\n    }\n\n    type BufferSource = ArrayBufferView | ArrayBuffer;\n\n    interface TextDecoderStream {\n        /** Returns encoding's name, lower cased. */\n        readonly encoding: string;\n        /** Returns `true` if error mode is \"fatal\", and `false` otherwise. */\n        readonly fatal: boolean;\n        /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */\n        readonly ignoreBOM: boolean;\n        readonly readable: ReadableStream<string>;\n        readonly writable: WritableStream<BufferSource>;\n        readonly [Symbol.toStringTag]: string;\n    }\n\n    const TextDecoderStream: {\n        prototype: TextDecoderStream;\n        new(encoding?: string, options?: TextDecoderOptions): TextDecoderStream;\n    };\n}\ndeclare module \"node:stream/web\" {\n    export * from \"stream/web\";\n}\n",
-	"timers/promises.d.ts": "/**\n * The `timers/promises` API provides an alternative set of timer functions\n * that return `Promise` objects. The API is accessible via `import timersPromises from 'node:timers/promises'`.\n *\n * ```js\n * import {\n *   setTimeout,\n *   setImmediate,\n *   setInterval,\n * } from 'timers/promises';\n * ```\n * @since v15.0.0\n */\ndeclare module \"timers/promises\" {\n    import { TimerOptions } from \"node:timers\";\n    /**\n     * ```js\n     * import {\n     *   setTimeout,\n     * } from 'timers/promises';\n     *\n     * const res = await setTimeout(100, 'result');\n     *\n     * console.log(res);  // Prints 'result'\n     * ```\n     * @since v15.0.0\n     * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.\n     * @param value A value with which the promise is fulfilled.\n     */\n    function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;\n    /**\n     * ```js\n     * import {\n     *   setImmediate,\n     * } from 'timers/promises';\n     *\n     * const res = await setImmediate('result');\n     *\n     * console.log(res);  // Prints 'result'\n     * ```\n     * @since v15.0.0\n     * @param value A value with which the promise is fulfilled.\n     */\n    function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;\n    /**\n     * Returns an async iterator that generates values in an interval of `delay` ms.\n     *\n     * ```js\n     * import {\n     *   setInterval,\n     * } from 'timers/promises';\n     *\n     * const interval = 100;\n     * for await (const startTime of setInterval(interval, Date.now())) {\n     *   const now = Date.now();\n     *   console.log(now);\n     *   if ((now - startTime) > 1000)\n     *     break;\n     * }\n     * console.log(Date.now());\n     * ```\n     * @since v15.9.0\n     */\n    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;\n\n    interface Scheduler {\n        /**\n         * ```js\n         * import { scheduler } from 'node:timers/promises';\n         *\n         * await scheduler.wait(1000); // Wait one second before continuing\n         * ```\n         * An experimental API defined by the Scheduling APIs draft specification being developed as a standard Web Platform API.\n         * Calling timersPromises.scheduler.wait(delay, options) is roughly equivalent to calling timersPromises.setTimeout(delay, undefined, options) except that the ref option is not supported.\n         * @since v16.14.0\n         * @experimental\n         * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.\n         */\n        wait: (delay?: number, options?: TimerOptions) => Promise<void>;\n        /**\n         * An experimental API defined by the Scheduling APIs draft specification being developed as a standard Web Platform API.\n         * Calling timersPromises.scheduler.yield() is equivalent to calling timersPromises.setImmediate() with no arguments.\n         * @since v16.14.0\n         * @experimental\n         */\n        yield: () => Promise<void>;\n    }\n\n    const scheduler: Scheduler;\n}\ndeclare module \"node:timers/promises\" {\n    export * from \"timers/promises\";\n}\n",
 	"ts5.6/buffer.buffer.d.ts": "declare module \"buffer\" {\n    global {\n        interface BufferConstructor {\n            // see ../buffer.d.ts for implementation shared with all TypeScript versions\n\n            /**\n             * Allocates a new buffer containing the given {str}.\n             *\n             * @param str String to store in buffer.\n             * @param encoding encoding to use, optional.  Default is 'utf8'\n             * @deprecated since v10.0.0 - Use `Buffer.from(string[, encoding])` instead.\n             */\n            new(str: string, encoding?: BufferEncoding): Buffer;\n            /**\n             * Allocates a new buffer of {size} octets.\n             *\n             * @param size count of octets to allocate.\n             * @deprecated since v10.0.0 - Use `Buffer.alloc()` instead (also see `Buffer.allocUnsafe()`).\n             */\n            new(size: number): Buffer;\n            /**\n             * Allocates a new buffer containing the given {array} of octets.\n             *\n             * @param array The octets to store.\n             * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.\n             */\n            new(array: Uint8Array): Buffer;\n            /**\n             * Produces a Buffer backed by the same allocated memory as\n             * the given {ArrayBuffer}/{SharedArrayBuffer}.\n             *\n             * @param arrayBuffer The ArrayBuffer with which to share memory.\n             * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.\n             */\n            new(arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer;\n            /**\n             * Allocates a new buffer containing the given {array} of octets.\n             *\n             * @param array The octets to store.\n             * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.\n             */\n            new(array: readonly any[]): Buffer;\n            /**\n             * Copies the passed {buffer} data onto a new {Buffer} instance.\n             *\n             * @param buffer The buffer to copy.\n             * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.\n             */\n            new(buffer: Buffer): Buffer;\n            /**\n             * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.\n             * Array entries outside that range will be truncated to fit into it.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * // Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.\n             * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);\n             * ```\n             *\n             * A `TypeError` will be thrown if `array` is not an `Array` or another type\n             * appropriate for `Buffer.from()` variants.\n             *\n             * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal`Buffer` pool like `Buffer.allocUnsafe()` does.\n             * @since v5.10.0\n             */\n            from(\n                arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>,\n                byteOffset?: number,\n                length?: number,\n            ): Buffer;\n            /**\n             * Creates a new Buffer using the passed {data}\n             * @param data data to create a new Buffer\n             */\n            from(data: Uint8Array | readonly number[]): Buffer;\n            from(data: WithImplicitCoercion<Uint8Array | readonly number[] | string>): Buffer;\n            /**\n             * Creates a new Buffer containing the given JavaScript string {str}.\n             * If provided, the {encoding} parameter identifies the character encoding.\n             * If not provided, {encoding} defaults to 'utf8'.\n             */\n            from(\n                str:\n                    | WithImplicitCoercion<string>\n                    | {\n                        [Symbol.toPrimitive](hint: \"string\"): string;\n                    },\n                encoding?: BufferEncoding,\n            ): Buffer;\n            /**\n             * Creates a new Buffer using the passed {data}\n             * @param values to create a new Buffer\n             */\n            of(...items: number[]): Buffer;\n            /**\n             * Returns a new `Buffer` which is the result of concatenating all the `Buffer` instances in the `list` together.\n             *\n             * If the list has no items, or if the `totalLength` is 0, then a new zero-length `Buffer` is returned.\n             *\n             * If `totalLength` is not provided, it is calculated from the `Buffer` instances\n             * in `list` by adding their lengths.\n             *\n             * If `totalLength` is provided, it is coerced to an unsigned integer. If the\n             * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is\n             * truncated to `totalLength`.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * // Create a single `Buffer` from a list of three `Buffer` instances.\n             *\n             * const buf1 = Buffer.alloc(10);\n             * const buf2 = Buffer.alloc(14);\n             * const buf3 = Buffer.alloc(18);\n             * const totalLength = buf1.length + buf2.length + buf3.length;\n             *\n             * console.log(totalLength);\n             * // Prints: 42\n             *\n             * const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);\n             *\n             * console.log(bufA);\n             * // Prints: <Buffer 00 00 00 00 ...>\n             * console.log(bufA.length);\n             * // Prints: 42\n             * ```\n             *\n             * `Buffer.concat()` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does.\n             * @since v0.7.11\n             * @param list List of `Buffer` or {@link Uint8Array} instances to concatenate.\n             * @param totalLength Total length of the `Buffer` instances in `list` when concatenated.\n             */\n            concat(list: readonly Uint8Array[], totalLength?: number): Buffer;\n            /**\n             * Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the`Buffer` will be zero-filled.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * const buf = Buffer.alloc(5);\n             *\n             * console.log(buf);\n             * // Prints: <Buffer 00 00 00 00 00>\n             * ```\n             *\n             * If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown.\n             *\n             * If `fill` is specified, the allocated `Buffer` will be initialized by calling `buf.fill(fill)`.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * const buf = Buffer.alloc(5, 'a');\n             *\n             * console.log(buf);\n             * // Prints: <Buffer 61 61 61 61 61>\n             * ```\n             *\n             * If both `fill` and `encoding` are specified, the allocated `Buffer` will be\n             * initialized by calling `buf.fill(fill, encoding)`.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');\n             *\n             * console.log(buf);\n             * // Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>\n             * ```\n             *\n             * Calling `Buffer.alloc()` can be measurably slower than the alternative `Buffer.allocUnsafe()` but ensures that the newly created `Buffer` instance\n             * contents will never contain sensitive data from previous allocations, including\n             * data that might not have been allocated for `Buffer`s.\n             *\n             * A `TypeError` will be thrown if `size` is not a number.\n             * @since v5.10.0\n             * @param size The desired length of the new `Buffer`.\n             * @param [fill=0] A value to pre-fill the new `Buffer` with.\n             * @param [encoding='utf8'] If `fill` is a string, this is its encoding.\n             */\n            alloc(size: number, fill?: string | Uint8Array | number, encoding?: BufferEncoding): Buffer;\n            /**\n             * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown.\n             *\n             * The underlying memory for `Buffer` instances created in this way is _not_\n             * _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `Buffer.alloc()` instead to initialize`Buffer` instances with zeroes.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * const buf = Buffer.allocUnsafe(10);\n             *\n             * console.log(buf);\n             * // Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>\n             *\n             * buf.fill(0);\n             *\n             * console.log(buf);\n             * // Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>\n             * ```\n             *\n             * A `TypeError` will be thrown if `size` is not a number.\n             *\n             * The `Buffer` module pre-allocates an internal `Buffer` instance of\n             * size `Buffer.poolSize` that is used as a pool for the fast allocation of new `Buffer` instances created using `Buffer.allocUnsafe()`, `Buffer.from(array)`, `Buffer.concat()`, and the\n             * deprecated `new Buffer(size)` constructor only when `size` is less than or equal\n             * to `Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two).\n             *\n             * Use of this pre-allocated internal memory pool is a key difference between\n             * calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.\n             * Specifically, `Buffer.alloc(size, fill)` will _never_ use the internal `Buffer`pool, while `Buffer.allocUnsafe(size).fill(fill)`_will_ use the internal`Buffer` pool if `size` is less\n             * than or equal to half `Buffer.poolSize`. The\n             * difference is subtle but can be important when an application requires the\n             * additional performance that `Buffer.allocUnsafe()` provides.\n             * @since v5.10.0\n             * @param size The desired length of the new `Buffer`.\n             */\n            allocUnsafe(size: number): Buffer;\n            /**\n             * Allocates a new `Buffer` of `size` bytes. If `size` is larger than {@link constants.MAX_LENGTH} or smaller than 0, `ERR_INVALID_ARG_VALUE` is thrown. A zero-length `Buffer` is created if\n             * `size` is 0.\n             *\n             * The underlying memory for `Buffer` instances created in this way is _not_\n             * _initialized_. The contents of the newly created `Buffer` are unknown and _may contain sensitive data_. Use `buf.fill(0)` to initialize\n             * such `Buffer` instances with zeroes.\n             *\n             * When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances,\n             * allocations under 4 KiB are sliced from a single pre-allocated `Buffer`. This\n             * allows applications to avoid the garbage collection overhead of creating many\n             * individually allocated `Buffer` instances. This approach improves both\n             * performance and memory usage by eliminating the need to track and clean up as\n             * many individual `ArrayBuffer` objects.\n             *\n             * However, in the case where a developer may need to retain a small chunk of\n             * memory from a pool for an indeterminate amount of time, it may be appropriate\n             * to create an un-pooled `Buffer` instance using `Buffer.allocUnsafeSlow()` and\n             * then copying out the relevant bits.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * // Need to keep around a few small chunks of memory.\n             * const store = [];\n             *\n             * socket.on('readable', () => {\n             *   let data;\n             *   while (null !== (data = readable.read())) {\n             *     // Allocate for retained data.\n             *     const sb = Buffer.allocUnsafeSlow(10);\n             *\n             *     // Copy the data into the new allocation.\n             *     data.copy(sb, 0, 0, 10);\n             *\n             *     store.push(sb);\n             *   }\n             * });\n             * ```\n             *\n             * A `TypeError` will be thrown if `size` is not a number.\n             * @since v5.12.0\n             * @param size The desired length of the new `Buffer`.\n             */\n            allocUnsafeSlow(size: number): Buffer;\n        }\n        interface Buffer extends Uint8Array {\n            // see ../buffer.d.ts for implementation shared with all TypeScript versions\n\n            /**\n             * Returns a new `Buffer` that references the same memory as the original, but\n             * offset and cropped by the `start` and `end` indices.\n             *\n             * This method is not compatible with the `Uint8Array.prototype.slice()`,\n             * which is a superclass of `Buffer`. To copy the slice, use`Uint8Array.prototype.slice()`.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * const buf = Buffer.from('buffer');\n             *\n             * const copiedBuf = Uint8Array.prototype.slice.call(buf);\n             * copiedBuf[0]++;\n             * console.log(copiedBuf.toString());\n             * // Prints: cuffer\n             *\n             * console.log(buf.toString());\n             * // Prints: buffer\n             *\n             * // With buf.slice(), the original buffer is modified.\n             * const notReallyCopiedBuf = buf.slice();\n             * notReallyCopiedBuf[0]++;\n             * console.log(notReallyCopiedBuf.toString());\n             * // Prints: cuffer\n             * console.log(buf.toString());\n             * // Also prints: cuffer (!)\n             * ```\n             * @since v0.3.0\n             * @deprecated Use `subarray` instead.\n             * @param [start=0] Where the new `Buffer` will start.\n             * @param [end=buf.length] Where the new `Buffer` will end (not inclusive).\n             */\n            slice(start?: number, end?: number): Buffer;\n            /**\n             * Returns a new `Buffer` that references the same memory as the original, but\n             * offset and cropped by the `start` and `end` indices.\n             *\n             * Specifying `end` greater than `buf.length` will return the same result as\n             * that of `end` equal to `buf.length`.\n             *\n             * This method is inherited from [`TypedArray.prototype.subarray()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray).\n             *\n             * Modifying the new `Buffer` slice will modify the memory in the original `Buffer`because the allocated memory of the two objects overlap.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * // Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte\n             * // from the original `Buffer`.\n             *\n             * const buf1 = Buffer.allocUnsafe(26);\n             *\n             * for (let i = 0; i < 26; i++) {\n             *   // 97 is the decimal ASCII value for 'a'.\n             *   buf1[i] = i + 97;\n             * }\n             *\n             * const buf2 = buf1.subarray(0, 3);\n             *\n             * console.log(buf2.toString('ascii', 0, buf2.length));\n             * // Prints: abc\n             *\n             * buf1[0] = 33;\n             *\n             * console.log(buf2.toString('ascii', 0, buf2.length));\n             * // Prints: !bc\n             * ```\n             *\n             * Specifying negative indexes causes the slice to be generated relative to the\n             * end of `buf` rather than the beginning.\n             *\n             * ```js\n             * import { Buffer } from 'node:buffer';\n             *\n             * const buf = Buffer.from('buffer');\n             *\n             * console.log(buf.subarray(-6, -1).toString());\n             * // Prints: buffe\n             * // (Equivalent to buf.subarray(0, 5).)\n             *\n             * console.log(buf.subarray(-6, -2).toString());\n             * // Prints: buff\n             * // (Equivalent to buf.subarray(0, 4).)\n             *\n             * console.log(buf.subarray(-5, -2).toString());\n             * // Prints: uff\n             * // (Equivalent to buf.subarray(1, 4).)\n             * ```\n             * @since v3.0.0\n             * @param [start=0] Where the new `Buffer` will start.\n             * @param [end=buf.length] Where the new `Buffer` will end (not inclusive).\n             */\n            subarray(start?: number, end?: number): Buffer;\n        }\n    }\n}\n",
 	"ts5.6/globals.typedarray.d.ts": "export {}; // Make this a module\n\ndeclare global {\n    namespace NodeJS {\n        type TypedArray =\n            | Uint8Array\n            | Uint8ClampedArray\n            | Uint16Array\n            | Uint32Array\n            | Int8Array\n            | Int16Array\n            | Int32Array\n            | BigUint64Array\n            | BigInt64Array\n            | Float32Array\n            | Float64Array;\n        type ArrayBufferView = TypedArray | DataView;\n    }\n}\n",
-	"ts5.6/index.d.ts": "/**\n * License for programmatically and manually incorporated\n * documentation aka. `JSDoc` from https://github.com/nodejs/node/tree/master/doc\n *\n * Copyright Node.js contributors. All rights reserved.\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\n// NOTE: These definitions support Node.js and TypeScript 4.9 through 5.6.\n\n// Reference required TypeScript libs:\n/// <reference lib=\"es2020\" />\n\n// TypeScript backwards-compatibility definitions:\n/// <reference path=\"../compatibility/index.d.ts\" />\n\n// Definitions specific to TypeScript 4.9 through 5.6:\n/// <reference path=\"./globals.typedarray.d.ts\" />\n/// <reference path=\"./buffer.buffer.d.ts\" />\n\n// Definitions for Node.js modules that are not specific to any version of TypeScript:\n/// <reference path=\"../globals.d.ts\" />\n/// <reference path=\"../assert.d.ts\" />\n/// <reference path=\"../assert/strict.d.ts\" />\n/// <reference path=\"../async_hooks.d.ts\" />\n/// <reference path=\"../buffer.d.ts\" />\n/// <reference path=\"../child_process.d.ts\" />\n/// <reference path=\"../cluster.d.ts\" />\n/// <reference path=\"../console.d.ts\" />\n/// <reference path=\"../constants.d.ts\" />\n/// <reference path=\"../crypto.d.ts\" />\n/// <reference path=\"../dgram.d.ts\" />\n/// <reference path=\"../diagnostics_channel.d.ts\" />\n/// <reference path=\"../dns.d.ts\" />\n/// <reference path=\"../dns/promises.d.ts\" />\n/// <reference path=\"../dom-events.d.ts\" />\n/// <reference path=\"../domain.d.ts\" />\n/// <reference path=\"../events.d.ts\" />\n/// <reference path=\"../fs.d.ts\" />\n/// <reference path=\"../fs/promises.d.ts\" />\n/// <reference path=\"../http.d.ts\" />\n/// <reference path=\"../http2.d.ts\" />\n/// <reference path=\"../https.d.ts\" />\n/// <reference path=\"../inspector.d.ts\" />\n/// <reference path=\"../module.d.ts\" />\n/// <reference path=\"../net.d.ts\" />\n/// <reference path=\"../os.d.ts\" />\n/// <reference path=\"../path.d.ts\" />\n/// <reference path=\"../perf_hooks.d.ts\" />\n/// <reference path=\"../process.d.ts\" />\n/// <reference path=\"../punycode.d.ts\" />\n/// <reference path=\"../querystring.d.ts\" />\n/// <reference path=\"../readline.d.ts\" />\n/// <reference path=\"../repl.d.ts\" />\n/// <reference path=\"../stream.d.ts\" />\n/// <reference path=\"../stream/promises.d.ts\" />\n/// <reference path=\"../stream/consumers.d.ts\" />\n/// <reference path=\"../stream/web.d.ts\" />\n/// <reference path=\"../string_decoder.d.ts\" />\n/// <reference path=\"../test.d.ts\" />\n/// <reference path=\"../timers.d.ts\" />\n/// <reference path=\"../timers/promises.d.ts\" />\n/// <reference path=\"../tls.d.ts\" />\n/// <reference path=\"../trace_events.d.ts\" />\n/// <reference path=\"../tty.d.ts\" />\n/// <reference path=\"../url.d.ts\" />\n/// <reference path=\"../util.d.ts\" />\n/// <reference path=\"../v8.d.ts\" />\n/// <reference path=\"../vm.d.ts\" />\n/// <reference path=\"../wasi.d.ts\" />\n/// <reference path=\"../worker_threads.d.ts\" />\n/// <reference path=\"../zlib.d.ts\" />\n"
+	"ts5.6/index.d.ts": "/**\n * License for programmatically and manually incorporated\n * documentation aka. `JSDoc` from https://github.com/nodejs/node/tree/master/doc\n *\n * Copyright Node.js contributors. All rights reserved.\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\n// NOTE: These definitions support Node.js and TypeScript 4.9 through 5.6.\n\n// Reference required TypeScript libs:\n/// <reference lib=\"es2020\" />\n\n// TypeScript backwards-compatibility definitions:\n/// <reference path=\"../compatibility/index.d.ts\" />\n\n// Definitions specific to TypeScript 4.9 through 5.6:\n/// <reference path=\"./globals.typedarray.d.ts\" />\n/// <reference path=\"./buffer.buffer.d.ts\" />\n\n// Definitions for Node.js modules that are not specific to any version of TypeScript:\n/// <reference path=\"../globals.d.ts\" />\n/// <reference path=\"../assert.d.ts\" />\n/// <reference path=\"../assert/strict.d.ts\" />\n/// <reference path=\"../async_hooks.d.ts\" />\n/// <reference path=\"../buffer.d.ts\" />\n/// <reference path=\"../child_process.d.ts\" />\n/// <reference path=\"../cluster.d.ts\" />\n/// <reference path=\"../console.d.ts\" />\n/// <reference path=\"../constants.d.ts\" />\n/// <reference path=\"../crypto.d.ts\" />\n/// <reference path=\"../dgram.d.ts\" />\n/// <reference path=\"../diagnostics_channel.d.ts\" />\n/// <reference path=\"../dns.d.ts\" />\n/// <reference path=\"../dns/promises.d.ts\" />\n/// <reference path=\"../dom-events.d.ts\" />\n/// <reference path=\"../domain.d.ts\" />\n/// <reference path=\"../events.d.ts\" />\n/// <reference path=\"../fs.d.ts\" />\n/// <reference path=\"../fs/promises.d.ts\" />\n/// <reference path=\"../http.d.ts\" />\n/// <reference path=\"../http2.d.ts\" />\n/// <reference path=\"../https.d.ts\" />\n/// <reference path=\"../inspector.d.ts\" />\n/// <reference path=\"../module.d.ts\" />\n/// <reference path=\"../net.d.ts\" />\n/// <reference path=\"../os.d.ts\" />\n/// <reference path=\"../path.d.ts\" />\n/// <reference path=\"../perf_hooks.d.ts\" />\n/// <reference path=\"../process.d.ts\" />\n/// <reference path=\"../punycode.d.ts\" />\n/// <reference path=\"../querystring.d.ts\" />\n/// <reference path=\"../readline.d.ts\" />\n/// <reference path=\"../repl.d.ts\" />\n/// <reference path=\"../stream.d.ts\" />\n/// <reference path=\"../stream/promises.d.ts\" />\n/// <reference path=\"../stream/consumers.d.ts\" />\n/// <reference path=\"../stream/web.d.ts\" />\n/// <reference path=\"../string_decoder.d.ts\" />\n/// <reference path=\"../test.d.ts\" />\n/// <reference path=\"../timers.d.ts\" />\n/// <reference path=\"../timers/promises.d.ts\" />\n/// <reference path=\"../tls.d.ts\" />\n/// <reference path=\"../trace_events.d.ts\" />\n/// <reference path=\"../tty.d.ts\" />\n/// <reference path=\"../url.d.ts\" />\n/// <reference path=\"../util.d.ts\" />\n/// <reference path=\"../v8.d.ts\" />\n/// <reference path=\"../vm.d.ts\" />\n/// <reference path=\"../wasi.d.ts\" />\n/// <reference path=\"../worker_threads.d.ts\" />\n/// <reference path=\"../zlib.d.ts\" />\n",
+	"timers/promises.d.ts": "/**\n * The `timers/promises` API provides an alternative set of timer functions\n * that return `Promise` objects. The API is accessible via `import timersPromises from 'node:timers/promises'`.\n *\n * ```js\n * import {\n *   setTimeout,\n *   setImmediate,\n *   setInterval,\n * } from 'timers/promises';\n * ```\n * @since v15.0.0\n */\ndeclare module \"timers/promises\" {\n    import { TimerOptions } from \"node:timers\";\n    /**\n     * ```js\n     * import {\n     *   setTimeout,\n     * } from 'timers/promises';\n     *\n     * const res = await setTimeout(100, 'result');\n     *\n     * console.log(res);  // Prints 'result'\n     * ```\n     * @since v15.0.0\n     * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.\n     * @param value A value with which the promise is fulfilled.\n     */\n    function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;\n    /**\n     * ```js\n     * import {\n     *   setImmediate,\n     * } from 'timers/promises';\n     *\n     * const res = await setImmediate('result');\n     *\n     * console.log(res);  // Prints 'result'\n     * ```\n     * @since v15.0.0\n     * @param value A value with which the promise is fulfilled.\n     */\n    function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;\n    /**\n     * Returns an async iterator that generates values in an interval of `delay` ms.\n     *\n     * ```js\n     * import {\n     *   setInterval,\n     * } from 'timers/promises';\n     *\n     * const interval = 100;\n     * for await (const startTime of setInterval(interval, Date.now())) {\n     *   const now = Date.now();\n     *   console.log(now);\n     *   if ((now - startTime) > 1000)\n     *     break;\n     * }\n     * console.log(Date.now());\n     * ```\n     * @since v15.9.0\n     */\n    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;\n\n    interface Scheduler {\n        /**\n         * ```js\n         * import { scheduler } from 'node:timers/promises';\n         *\n         * await scheduler.wait(1000); // Wait one second before continuing\n         * ```\n         * An experimental API defined by the Scheduling APIs draft specification being developed as a standard Web Platform API.\n         * Calling timersPromises.scheduler.wait(delay, options) is roughly equivalent to calling timersPromises.setTimeout(delay, undefined, options) except that the ref option is not supported.\n         * @since v16.14.0\n         * @experimental\n         * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.\n         */\n        wait: (delay?: number, options?: TimerOptions) => Promise<void>;\n        /**\n         * An experimental API defined by the Scheduling APIs draft specification being developed as a standard Web Platform API.\n         * Calling timersPromises.scheduler.yield() is equivalent to calling timersPromises.setImmediate() with no arguments.\n         * @since v16.14.0\n         * @experimental\n         */\n        yield: () => Promise<void>;\n    }\n\n    const scheduler: Scheduler;\n}\ndeclare module \"node:timers/promises\" {\n    export * from \"timers/promises\";\n}\n"
 };
 
 export { typescriptWorkerNodeTypes as default };