@openclaw/whatsapp 2026.7.1-beta.2 → 2026.7.1-beta.5

package/node_modules/@cacheable/utils/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@cacheable/utils",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "Cacheable Utilities for Caching Libraries",
   "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       },
       "require": {
         "types": "./dist/index.d.cts",
@@ -31,7 +31,7 @@
     "keyv": "^5.6.0"
   },
   "devDependencies": {
-    "tsup": "^8.5.1",
+    "tsdown": "^0.22.0",
     "typescript": "^5.9.3"
   },
   "keywords": [
@@ -47,7 +47,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts --clean",
+    "build": "rimraf ./dist && tsdown src/index.ts --format cjs,esm --dts --clean",
     "lint": "biome check --write --error-on-warnings",
     "test": "pnpm lint && vitest run --coverage",
     "test:ci": "biome check --error-on-warnings && vitest run --coverage",

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Tue, 19 May 2026 17:48:56 GMT
+ * Last updated: Wed, 01 Jul 2026 11:03:38 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/assert/strict.d.ts

@@ -3,6 +3,7 @@ declare module "node:assert/strict" {
         Assert,
         AssertionError,
         AssertionErrorOptions,
+        AssertMessageFunction,
         AssertOptions,
         AssertPredicate,
         AssertStrict,
@@ -21,7 +22,15 @@ declare module "node:assert/strict" {
         strictEqual,
         throws,
     } from "node:assert";
-    function strict(value: unknown, message?: string | Error): asserts value;
+    function strict(
+        value: unknown,
+        message?: Error | AssertMessageFunction,
+    ): asserts value;
+    function strict(
+        value: unknown,
+        message: string,
+        ...args: unknown[]
+    ): asserts value;
     namespace strict {
         export {
             Assert,

package/node_modules/@types/node/assert.d.ts

@@ -5,7 +5,15 @@ declare module "node:assert" {
      * @since v0.5.9
      * @param value The input that is checked for being truthy.
      */
-    function assert(value: unknown, message?: string | Error): asserts value;
+    function assert(
+        value: unknown,
+        message?: Error | assert.AssertMessageFunction,
+    ): asserts value;
+    function assert(
+        value: unknown,
+        message: string,
+        ...args: unknown[]
+    ): asserts value;
     const kOptions: unique symbol;
     namespace assert {
         type AssertMethodNames =
@@ -177,6 +185,7 @@ declare module "node:assert" {
              */
             operator: string;
         }
+        type AssertMessageFunction = (actual: unknown, expected: unknown) => string;
         type AssertPredicate = RegExp | (new() => object) | ((thrown: unknown) => boolean) | object | Error;
         /**
          * Throws an `AssertionError` with the provided error message or a default
@@ -255,7 +264,15 @@ declare module "node:assert" {
          * ```
          * @since v0.1.21
          */
-        function ok(value: unknown, message?: string | Error): asserts value;
+        function ok(
+            value: unknown,
+            message?: Error | AssertMessageFunction,
+        ): asserts value;
+        function ok(
+            value: unknown,
+            message: string,
+            ...args: unknown[]
+        ): asserts value;
         /**
          * **Strict assertion mode**
          *
@@ -289,7 +306,17 @@ declare module "node:assert" {
          * error message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown instead of the `AssertionError`.
          * @since v0.1.21
          */
-        function equal(actual: unknown, expected: unknown, message?: string | Error): void;
+        function equal(
+            actual: unknown,
+            expected: unknown,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function equal(
+            actual: unknown,
+            expected: unknown,
+            message: string,
+            ...args: unknown[]
+        ): void;
         /**
          * **Strict assertion mode**
          *
@@ -319,7 +346,17 @@ declare module "node:assert" {
          * message is assigned. If the `message` parameter is an instance of an `Error` then it will be thrown instead of the `AssertionError`.
          * @since v0.1.21
          */
-        function notEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function notEqual(
+            actual: unknown,
+            expected: unknown,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function notEqual(
+            actual: unknown,
+            expected: unknown,
+            message: string,
+            ...args: unknown[]
+        ): void;
         /**
          * **Strict assertion mode**
          *
@@ -337,7 +374,17 @@ declare module "node:assert" {
          * are also recursively evaluated by the following rules.
          * @since v0.1.21
          */
-        function deepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function deepEqual(
+            actual: unknown,
+            expected: unknown,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function deepEqual(
+            actual: unknown,
+            expected: unknown,
+            message: string,
+            ...args: unknown[]
+        ): void;
         /**
          * **Strict assertion mode**
          *
@@ -387,7 +434,17 @@ declare module "node:assert" {
          * instead of the `AssertionError`.
          * @since v0.1.21
          */
-        function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function notDeepEqual(
+            actual: unknown,
+            expected: unknown,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function notDeepEqual(
+            actual: unknown,
+            expected: unknown,
+            message: string,
+            ...args: unknown[]
+        ): void;
         /**
          * Tests strict equality between the `actual` and `expected` parameters as
          * determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
@@ -425,7 +482,17 @@ declare module "node:assert" {
          * instead of the `AssertionError`.
          * @since v0.1.21
          */
-        function strictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
+        function strictEqual<T>(
+            actual: unknown,
+            expected: T,
+            message?: Error | AssertMessageFunction,
+        ): asserts actual is T;
+        function strictEqual<T>(
+            actual: unknown,
+            expected: T,
+            message: string,
+            ...args: unknown[]
+        ): asserts actual is T;
         /**
          * Tests strict inequality between the `actual` and `expected` parameters as
          * determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
@@ -450,14 +517,34 @@ declare module "node:assert" {
          * instead of the `AssertionError`.
          * @since v0.1.21
          */
-        function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function notStrictEqual(
+            actual: unknown,
+            expected: unknown,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function notStrictEqual(
+            actual: unknown,
+            expected: unknown,
+            message: string,
+            ...args: unknown[]
+        ): void;
         /**
          * Tests for deep equality between the `actual` and `expected` parameters.
          * "Deep" equality means that the enumerable "own" properties of child objects
          * are recursively evaluated also by the following rules.
          * @since v1.2.0
          */
-        function deepStrictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
+        function deepStrictEqual<T>(
+            actual: unknown,
+            expected: T,
+            message?: Error | AssertMessageFunction,
+        ): asserts actual is T;
+        function deepStrictEqual<T>(
+            actual: unknown,
+            expected: T,
+            message: string,
+            ...args: unknown[]
+        ): asserts actual is T;
         /**
          * Tests for deep strict inequality. Opposite of {@link deepStrictEqual}.
          *
@@ -475,7 +562,17 @@ declare module "node:assert" {
          * instead of the `AssertionError`.
          * @since v1.2.0
          */
-        function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function notDeepStrictEqual(
+            actual: unknown,
+            expected: unknown,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function notDeepStrictEqual(
+            actual: unknown,
+            expected: unknown,
+            message: string,
+            ...args: unknown[]
+        ): void;
         /**
          * Expects the function `fn` to throw an error.
          *
@@ -766,7 +863,7 @@ declare module "node:assert" {
          * check that the promise is rejected.
          *
          * If `asyncFn` is a function and it throws an error synchronously, `assert.rejects()` will return a rejected `Promise` with that error. If the
-         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v25.x/api/errors.html#err_invalid_return_value)
+         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v26.x/api/errors.html#err_invalid_return_value)
          * error. In both cases the error handler is skipped.
          *
          * Besides the async nature to await the completion behaves identically to {@link throws}.
@@ -836,7 +933,7 @@ declare module "node:assert" {
          *
          * If `asyncFn` is a function and it throws an error synchronously, `assert.doesNotReject()` will return a rejected `Promise` with that error. If
          * the function does not return a promise, `assert.doesNotReject()` will return a
-         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v25.x/api/errors.html#err_invalid_return_value) error. In both cases
+         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v26.x/api/errors.html#err_invalid_return_value) error. In both cases
          * the error handler is skipped.
          *
          * Using `assert.doesNotReject()` is actually not useful because there is little
@@ -899,10 +996,20 @@ declare module "node:assert" {
          * If the values do not match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an [Error](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v26.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
-        function match(value: string, regExp: RegExp, message?: string | Error): void;
+        function match(
+            value: string,
+            regExp: RegExp,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function match(
+            value: string,
+            regExp: RegExp,
+            message: string,
+            ...args: unknown[]
+        ): void;
         /**
          * Expects the `string` input not to match the regular expression.
          *
@@ -922,10 +1029,20 @@ declare module "node:assert" {
          * If the values do match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an [Error](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v26.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
-        function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
+        function doesNotMatch(
+            value: string,
+            regExp: RegExp,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function doesNotMatch(
+            value: string,
+            regExp: RegExp,
+            message: string,
+            ...args: unknown[]
+        ): void;
         /**
          * Tests for partial deep equality between the `actual` and `expected` parameters.
          * "Deep" equality means that the enumerable "own" properties of child objects
@@ -937,7 +1054,17 @@ declare module "node:assert" {
          * behaving as a super set of it.
          * @since v22.13.0
          */
-        function partialDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function partialDeepStrictEqual(
+            actual: unknown,
+            expected: unknown,
+            message?: Error | AssertMessageFunction,
+        ): void;
+        function partialDeepStrictEqual(
+            actual: unknown,
+            expected: unknown,
+            message: string,
+            ...args: unknown[]
+        ): void;
     }
     namespace assert {
         export { strict };

package/node_modules/@types/node/async_hooks.d.ts

@@ -28,7 +28,7 @@ declare module "node:async_hooks" {
      * ```
      *
      * Promise contexts may not get precise `executionAsyncIds` by default.
-     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promise-execution-tracking).
+     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#promise-execution-tracking).
      * @since v8.1.0
      * @return The `asyncId` of the current execution context. Useful to track when something calls.
      */
@@ -101,29 +101,29 @@ declare module "node:async_hooks" {
      * ```
      *
      * Promise contexts may not get valid `triggerAsyncId`s by default. See
-     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promise-execution-tracking).
+     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#promise-execution-tracking).
      * @return The ID of the resource responsible for calling the callback that is currently being executed.
      */
     function triggerAsyncId(): number;
     interface HookCallbacks {
         /**
-         * The [`init` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#initasyncid-type-triggerasyncid-resource).
+         * The [`init` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#initasyncid-type-triggerasyncid-resource).
          */
         init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
         /**
-         * The [`before` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#beforeasyncid).
+         * The [`before` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#beforeasyncid).
          */
         before?(asyncId: number): void;
         /**
-         * The [`after` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#afterasyncid).
+         * The [`after` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#afterasyncid).
          */
         after?(asyncId: number): void;
         /**
-         * The [`promiseResolve` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promiseresolveasyncid).
+         * The [`promiseResolve` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#promiseresolveasyncid).
          */
         promiseResolve?(asyncId: number): void;
         /**
-         * The [`destroy` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#destroyasyncid).
+         * The [`destroy` callback](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#destroyasyncid).
          */
         destroy?(asyncId: number): void;
         /**
@@ -153,7 +153,7 @@ declare module "node:async_hooks" {
      * All callbacks are optional. For example, if only resource cleanup needs to
      * be tracked, then only the `destroy` callback needs to be passed. The
      * specifics of all functions that can be passed to `callbacks` is in the
-     * [Hook Callbacks](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#hook-callbacks) section.
+     * [Hook Callbacks](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#hook-callbacks) section.
      *
      * ```js
      * import { createHook } from 'node:async_hooks';
@@ -184,7 +184,7 @@ declare module "node:async_hooks" {
      * via the async hooks mechanism, the `init()`, `before()`, `after()`, and
      * `destroy()` callbacks _must not_ be async functions that return promises.
      * @since v8.1.0
-     * @param options The [Hook Callbacks](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#hook-callbacks) to register
+     * @param options The [Hook Callbacks](https://nodejs.org/docs/latest-v26.x/api/async_hooks.html#hook-callbacks) to register
      * @returns Instance used for disabling and enabling hooks
      */
     function createHook(options: HookCallbacks): AsyncHook;

package/node_modules/@types/node/buffer.d.ts

@@ -75,11 +75,6 @@ declare module "node:buffer" {
      */
     export function resolveObjectURL(id: string): Blob | undefined;
     export { type AllowSharedBuffer, Buffer, type NonSharedBuffer };
-    /** @deprecated This alias will be removed in a future version. Use the canonical `BlobPropertyBag` instead. */
-    // TODO: remove in future major
-    export interface BlobOptions extends BlobPropertyBag {}
-    /** @deprecated This alias will be removed in a future version. Use the canonical `FilePropertyBag` instead. */
-    export interface FileOptions extends FilePropertyBag {}
     export type WithImplicitCoercion<T> =
         | T
         | { valueOf(): T }
@@ -1555,11 +1550,12 @@ declare module "node:buffer" {
             /**
              * If `value` is:
              *
-             * * a string, `value` is interpreted according to the character encoding in `encoding`.
-             * * a `Buffer` or [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), `value` will be used in its entirety.
-             * To compare a partial `Buffer`, use `buf.subarray`.
+             * * a string, `value` is interpreted according to the character encoding in
+             *   `encoding`.
+             * * a `Buffer` or `Uint8Array`, `value` will be used in its entirety.
+             *   To compare a partial `Buffer`, use `buf.subarray`.
              * * a number, `value` will be interpreted as an unsigned 8-bit integer
-             * value between `0` and `255`.
+             *   value between `0` and `255`.
              *
              * ```js
              * import { Buffer } from 'node:buffer';
@@ -1587,12 +1583,13 @@ declare module "node:buffer" {
              * // Prints: 6
              * ```
              *
-             * If `value` is not a string, number, or `Buffer`, this method will throw a `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
+             * If `value` is not a string, number, or `Buffer`, this method will throw a
+             * `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
              * an integer between 0 and 255.
              *
              * If `byteOffset` is not a number, it will be coerced to a number. If the result
              * of coercion is `NaN` or `0`, then the entire buffer will be searched. This
-             * behavior matches [`String.prototype.indexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf).
+             * behavior matches `String.prototype.indexOf()`.
              *
              * ```js
              * import { Buffer } from 'node:buffer';
@@ -1613,14 +1610,27 @@ declare module "node:buffer" {
              * ```
              *
              * If `value` is an empty string or empty `Buffer` and `byteOffset` is less
-             * than `buf.length`, `byteOffset` will be returned. If `value` is empty and`byteOffset` is at least `buf.length`, `buf.length` will be returned.
+             * than `buf.length`, `byteOffset` will be returned. If `value` is empty and
+             * `byteOffset` is at least `buf.length`, `buf.length` will be returned.
              * @since v1.5.0
              * @param value What to search for.
-             * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
-             * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`.
-             * @return The index of the first occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`.
-             */
-            indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+             * @param start Where to begin searching in `buf`. If negative, then
+             * offset is calculated from the end of `buf`. **Default:** `0`.
+             * @param end Where to stop searching in `buf` (exclusive). **Default:**
+             * `buf.length`.
+             * @param encoding If `value` is a string, this is the encoding used to
+             * determine the binary representation of the string that will be searched for in
+             * `buf`. **Default:** `'utf8'`.
+             * @returns The index of the first occurrence of `value` in `buf`, or
+             * `-1` if `buf` does not contain `value`.
+             */
+            indexOf(
+                value: string | number | Uint8Array,
+                start?: number,
+                end?: number,
+                encoding?: BufferEncoding,
+            ): number;
+            indexOf(value: string | number | Uint8Array, start: number, encoding: BufferEncoding): number;
             indexOf(value: string | number | Uint8Array, encoding: BufferEncoding): number;
             /**
              * Identical to `buf.indexOf()`, except the last occurrence of `value` is found
@@ -1654,12 +1664,13 @@ declare module "node:buffer" {
              * // Prints: 4
              * ```
              *
-             * If `value` is not a string, number, or `Buffer`, this method will throw a `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
+             * If `value` is not a string, number, or `Buffer`, this method will throw a
+             * `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
              * an integer between 0 and 255.
              *
              * If `byteOffset` is not a number, it will be coerced to a number. Any arguments
              * that coerce to `NaN`, like `{}` or `undefined`, will search the whole buffer.
-             * This behavior matches [`String.prototype.lastIndexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf).
+             * This behavior matches `String.prototype.lastIndexOf()`.
              *
              * ```js
              * import { Buffer } from 'node:buffer';
@@ -1685,11 +1696,24 @@ declare module "node:buffer" {
              * If `value` is an empty string or empty `Buffer`, `byteOffset` will be returned.
              * @since v6.0.0
              * @param value What to search for.
-             * @param [byteOffset=buf.length - 1] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
-             * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`.
-             * @return The index of the last occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`.
-             */
-            lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+             * @param start Where to begin searching in `buf`. If negative, then
+             * offset is calculated from the end of `buf`. **Default:**
+             * `buf.length - 1`.
+             * @param end Where to stop searching in `buf` (exclusive). **Default:**
+             * `buf.length`.
+             * @param encoding If `value` is a string, this is the encoding used to
+             * determine the binary representation of the string that will be searched for in
+             * `buf`. **Default:** `'utf8'`.
+             * @returns The index of the last occurrence of `value` in `buf`, or
+             * `-1` if `buf` does not contain `value`.
+             */
+            lastIndexOf(
+                value: string | number | Uint8Array,
+                start?: number,
+                end?: number,
+                encoding?: BufferEncoding,
+            ): number;
+            lastIndexOf(value: string | number | Uint8Array, start: number, encoding: BufferEncoding): number;
             lastIndexOf(value: string | number | Uint8Array, encoding: BufferEncoding): number;
             /**
              * Equivalent to `buf.indexOf() !== -1`.
@@ -1716,12 +1740,22 @@ declare module "node:buffer" {
              * ```
              * @since v5.3.0
              * @param value What to search for.
-             * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
-             * @param [encoding='utf8'] If `value` is a string, this is its encoding.
-             * @return `true` if `value` was found in `buf`, `false` otherwise.
-             */
-            includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
-            includes(value: string | number | Buffer, encoding: BufferEncoding): boolean;
+             * @param start Where to begin searching in `buf`. If negative, then
+             * offset is calculated from the end of `buf`. **Default:** `0`.
+             * @param end Where to stop searching in `buf` (exclusive). **Default:**
+             * `buf.length`.
+             * @param encoding If `value` is a string, this is its encoding.
+             * **Default:** `'utf8'`.
+             * @returns `true` if `value` was found in `buf`, `false` otherwise.
+             */
+            includes(
+                value: string | number | Uint8Array,
+                start?: number,
+                end?: number,
+                encoding?: BufferEncoding,
+            ): boolean;
+            includes(value: string | number | Uint8Array, start: number, encoding: BufferEncoding): boolean;
+            includes(value: string | number | Uint8Array, encoding: BufferEncoding): boolean;
         }
         var Buffer: BufferConstructor;
     }