plugin-data-source-mssql 2.0.6 → 2.0.8

package/dist/tedious/node_modules/@types/node/process.d.ts

@@ -1474,30 +1474,35 @@ declare module "node:process" {
                  * Will generate an object similar to:
                  *
                  * ```console
-                 * { node: '20.2.0',
-                 *   acorn: '8.8.2',
-                 *   ada: '2.4.0',
-                 *   ares: '1.19.0',
-                 *   base64: '0.5.0',
-                 *   brotli: '1.0.9',
-                 *   cjs_module_lexer: '1.2.2',
-                 *   cldr: '43.0',
-                 *   icu: '73.1',
-                 *   llhttp: '8.1.0',
-                 *   modules: '115',
-                 *   napi: '8',
-                 *   nghttp2: '1.52.0',
-                 *   nghttp3: '0.7.0',
-                 *   ngtcp2: '0.8.1',
-                 *   openssl: '3.0.8+quic',
-                 *   simdutf: '3.2.9',
-                 *   tz: '2023c',
-                 *   undici: '5.22.0',
-                 *   unicode: '15.0',
-                 *   uv: '1.44.2',
-                 *   uvwasi: '0.0.16',
-                 *   v8: '11.3.244.8-node.9',
-                 *   zlib: '1.2.13' }
+                 * { node: '26.0.0-pre',
+                 *   acorn: '8.15.0',
+                 *   ada: '3.4.1',
+                 *   amaro: '1.1.5',
+                 *   ares: '1.34.6',
+                 *   brotli: '1.2.0',
+                 *   merve: '1.0.0',
+                 *   cldr: '48.0',
+                 *   icu: '78.2',
+                 *   llhttp: '9.3.0',
+                 *   modules: '144',
+                 *   napi: '10',
+                 *   nbytes: '0.1.1',
+                 *   ncrypto: '0.0.1',
+                 *   nghttp2: '1.68.0',
+                 *   nghttp3: '',
+                 *   ngtcp2: '',
+                 *   openssl: '3.5.4',
+                 *   simdjson: '4.2.4',
+                 *   simdutf: '7.3.3',
+                 *   sqlite: '3.51.2',
+                 *   tz: '2025c',
+                 *   undici: '7.18.2',
+                 *   unicode: '17.0',
+                 *   uv: '1.51.0',
+                 *   uvwasi: '0.0.23',
+                 *   v8: '14.3.127.18-node.10',
+                 *   zlib: '1.3.1-e00f703',
+                 *   zstd: '1.5.7' }
                  * ```
                  * @since v0.2.0
                  */

package/dist/tedious/node_modules/@types/node/sqlite.d.ts

@@ -87,6 +87,29 @@ declare module "node:sqlite" {
          * @default true
          */
         defensive?: boolean | undefined;
+        /**
+         * Configuration for various SQLite limits. These limits
+         * can be used to prevent excessive resource consumption when handling
+         * potentially malicious input. See [Run-Time Limits](https://www.sqlite.org/c3ref/c_limit_attached.html) and [Limit Constants](https://www.sqlite.org/c3ref/limit.html)
+         * in the SQLite documentation for details. Default values are determined by
+         * SQLite's compile-time defaults and may vary depending on how SQLite was
+         * built. The following properties are supported:
+         * @since v25.8.0
+         */
+        limits?: NodeJS.PartialOptions<DatabaseLimits> | undefined;
+    }
+    interface DatabaseLimits {
+        length: number;
+        sqlLength: number;
+        column: number;
+        exprDepth: number;
+        compoundSelect: number;
+        vdbeOp: number;
+        functionArg: number;
+        attach: number;
+        likePatternLength: number;
+        variableNumber: number;
+        triggerDepth: number;
     }
     interface CreateSessionOptions {
         /**
@@ -311,18 +334,17 @@ declare module "node:sqlite" {
          * @since v22.13.0
          * @param name The name of the SQLite function to create.
          * @param options Optional configuration settings for the function.
-         * @param func The JavaScript function to call when the SQLite
-         * function is invoked. The return value of this function should be a valid
-         * SQLite data type: see
-         * [Type conversion between JavaScript and SQLite](https://nodejs.org/docs/latest-v25.x/api/sqlite.html#type-conversion-between-javascript-and-sqlite).
-         * The result defaults to `NULL` if the return value is `undefined`.
+         * @param fn The JavaScript function to call when the SQLite function is
+         * invoked. The return value of this function should be a valid SQLite data type:
+         * see [Type conversion between JavaScript and SQLite](https://nodejs.org/docs/latest-v25.x/api/sqlite.html#type-conversion-between-javascript-and-sqlite). The result defaults to
+         * `NULL` if the return value is `undefined`.
          */
         function(
             name: string,
             options: FunctionOptions,
-            func: (...args: SQLOutputValue[]) => SQLInputValue,
+            fn: (...args: SQLOutputValue[]) => SQLInputValue,
         ): void;
-        function(name: string, func: (...args: SQLOutputValue[]) => SQLInputValue): void;
+        function(name: string, fn: (...args: SQLOutputValue[]) => SQLInputValue): void;
         /**
          * Sets an authorizer callback that SQLite will invoke whenever it attempts to
          * access data or modify the database schema through prepared statements.
@@ -392,6 +414,31 @@ declare module "node:sqlite" {
          * @since v24.0.0
          */
         readonly isTransaction: boolean;
+        /**
+         * An object for getting and setting SQLite database limits at runtime.
+         * Each property corresponds to an SQLite limit and can be read or written.
+         *
+         * ```js
+         * const db = new DatabaseSync(':memory:');
+         *
+         * // Read current limit
+         * console.log(db.limits.length);
+         *
+         * // Set a new limit
+         * db.limits.sqlLength = 100000;
+         *
+         * // Reset a limit to its compile-time maximum
+         * db.limits.sqlLength = Infinity;
+         * ```
+         *
+         * Available properties: `length`, `sqlLength`, `column`, `exprDepth`,
+         * `compoundSelect`, `vdbeOp`, `functionArg`, `attach`, `likePatternLength`,
+         * `variableNumber`, `triggerDepth`.
+         *
+         * Setting a property to `Infinity` resets the limit to its compile-time maximum value.
+         * @since v25.8.0
+         */
+        readonly limits: DatabaseLimits;
         /**
          * Opens the database specified in the `path` argument of the `DatabaseSync`constructor. This method should only be used when the database is not opened via
          * the constructor. An exception is thrown if the database is already open.

package/dist/tedious/node_modules/@types/node/stream/web.d.ts

@@ -52,12 +52,16 @@ declare module "node:stream/web" {
         signal?: AbortSignal;
     }
     interface Transformer<I = any, O = any> {
+        cancel?: TransformerCancelCallback;
         flush?: TransformerFlushCallback<O>;
         readableType?: undefined;
         start?: TransformerStartCallback<O>;
         transform?: TransformerTransformCallback<I, O>;
         writableType?: undefined;
     }
+    interface TransformerCancelCallback {
+        (reason: any): void | PromiseLike<void>;
+    }
     interface TransformerFlushCallback<O> {
         (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
     }

package/dist/tedious/node_modules/@types/node/stream.d.ts

@@ -1067,7 +1067,7 @@ declare module "node:stream" {
             writableCorked?: number | undefined;
         }
         interface DuplexToWebOptions {
-            type?: web.ReadableStreamType | undefined;
+            readableType?: web.ReadableStreamType | undefined;
         }
         interface DuplexEventMap extends ReadableEventMap, WritableEventMap {}
         /**

package/dist/tedious/node_modules/@types/node/test/reporters.d.ts

@@ -8,6 +8,7 @@ declare module "node:test/reporters" {
         | { type: "test:diagnostic"; data: EventData.TestDiagnostic }
         | { type: "test:enqueue"; data: EventData.TestEnqueue }
         | { type: "test:fail"; data: EventData.TestFail }
+        | { type: "test:interrupted"; data: EventData.TestInterrupted }
         | { type: "test:pass"; data: EventData.TestPass }
         | { type: "test:plan"; data: EventData.TestPlan }
         | { type: "test:start"; data: EventData.TestStart }

package/dist/tedious/node_modules/@types/node/test.d.ts

@@ -1,5 +1,5 @@
 declare module "node:test" {
-    import { AssertMethodNames } from "node:assert";
+    import { AssertMethodNames, AssertPredicate } from "node:assert";
     import { Readable, ReadableEventMap } from "node:stream";
     import { TestEvent } from "node:test/reporters";
     import { URL } from "node:url";
@@ -111,7 +111,12 @@ declare module "node:test" {
             function only(name?: string, fn?: SuiteFn): Promise<void>;
             function only(options?: TestOptions, fn?: SuiteFn): Promise<void>;
             function only(fn?: SuiteFn): Promise<void>;
-            // added in v25.5.0, undocumented
+            /**
+             * This flips the pass/fail reporting for a specific test or suite: a flagged test
+             * case must throw in order to pass, and a flagged test case that does not throw
+             * fails.
+             * @since v25.5.0
+             */
             function expectFailure(name?: string, options?: TestOptions, fn?: SuiteFn): Promise<void>;
             function expectFailure(name?: string, fn?: SuiteFn): Promise<void>;
             function expectFailure(options?: TestOptions, fn?: SuiteFn): Promise<void>;
@@ -334,6 +339,7 @@ declare module "node:test" {
              * This options is not compatible with `isolation='none'`. These variables will override
              * those from the main process, and are not merged with `process.env`.
              * @since v25.6.0
+             * @default process.env
              */
             env?: NodeJS.ProcessEnv | undefined;
         }
@@ -345,6 +351,7 @@ declare module "node:test" {
             "test:diagnostic": [data: EventData.TestDiagnostic];
             "test:enqueue": [data: EventData.TestEnqueue];
             "test:fail": [data: EventData.TestFail];
+            "test:interrupted": [data: EventData.TestInterrupted];
             "test:pass": [data: EventData.TestPass];
             "test:plan": [data: EventData.TestPlan];
             "test:start": [data: EventData.TestStart];
@@ -736,6 +743,13 @@ declare module "node:test" {
                  */
                 skip?: string | boolean;
             }
+            interface TestInterrupted {
+                /**
+                 * An array of objects containing information about the
+                 * interrupted tests.
+                 */
+                tests: TestStart[];
+            }
             interface TestPass extends LocationInfo {
                 /**
                  * Additional execution metadata.
@@ -983,6 +997,34 @@ declare module "node:test" {
              * @since v21.7.0, v20.12.0
              */
             readonly attempt: number;
+            /**
+             * The unique identifier of the worker running the current test file. This value is
+             * derived from the `NODE_TEST_WORKER_ID` environment variable. When running tests
+             * with `--test-isolation=process` (the default), each test file runs in a separate
+             * child process and is assigned a worker ID from 1 to N, where N is the number of
+             * concurrent workers. When running with `--test-isolation=none`, all tests run in
+             * the same process and the worker ID is always 1. This value is `undefined` when
+             * not running in a test context.
+             *
+             * This property is useful for splitting resources (like database connections or
+             * server ports) across concurrent test files:
+             *
+             * ```js
+             * import { test } from 'node:test';
+             * import { process } from 'node:process';
+             *
+             * test('database operations', async (t) => {
+             *   // Worker ID is available via context
+             *   console.log(`Running in worker ${t.workerId}`);
+             *
+             *   // Or via environment variable (available at import time)
+             *   const workerId = process.env.NODE_TEST_WORKER_ID;
+             *   // Use workerId to allocate separate resources per worker
+             * });
+             * ```
+             * @since v25.8.0
+             */
+            readonly workerId: number | undefined;
             /**
              * This function is used to set the number of assertions and subtests that are expected to run
              * within the test. If the number of assertions and subtests that run does not match the
@@ -1263,6 +1305,17 @@ declare module "node:test" {
              * @default false
              */
             concurrency?: number | boolean | undefined;
+            /**
+             * If truthy, the test is expected to fail. If a non-empty string is provided, that string is displayed
+             * in the test results as the reason why the test is expected to fail. If a
+             * `RegExp`, `Function`, `Object`, or `Error` is provided directly (without wrapping in `{ match: … }`), the test passes
+             * only if the thrown error matches, following the behavior of
+             * `assert.throws`. To provide both a reason and validation, pass an object
+             * with `label` (string) and `match` (RegExp, Function, Object, or Error).
+             * @since v25.5.0
+             * @default false
+             */
+            expectFailure?: boolean | string | AssertPredicate | undefined;
             /**
              * If truthy, and the test context is configured to run `only` tests, then this test will be
              * run. Otherwise, the test is skipped.
@@ -1301,8 +1354,6 @@ declare module "node:test" {
              * @since v22.2.0
              */
             plan?: number | undefined;
-            // added in v25.5.0, undocumented
-            expectFailure?: boolean | undefined;
         }
         /**
          * This function creates a hook that runs before executing a suite.

package/dist/tedious/node_modules/@types/node/url.d.ts

@@ -229,9 +229,31 @@ declare module "node:url" {
      * * `result` is returned.
      * @since v0.1.25
      * @legacy Use the WHATWG URL API instead.
-     * @param urlObject A URL object (as returned by `url.parse()` or constructed otherwise). If a string, it is converted to an object by passing it to `url.parse()`.
+     * @param urlObject A URL object (as returned by `url.parse()` or constructed otherwise).
      */
-    function format(urlObject: UrlObject | string): string;
+    function format(urlObject: UrlObject): string;
+    /**
+     * `url.format(urlString)` is shorthand for `url.format(url.parse(urlString))`.
+     *
+     * Because it invokes the deprecated `url.parse()` internally, passing a string argument
+     * to `url.format()` is itself deprecated.
+     *
+     * Canonicalizing a URL string can be performed using the WHATWG URL API, by
+     * constructing a new URL object and calling `url.toString()`.
+     *
+     * ```js
+     * import { URL } from 'node:url';
+     *
+     * const unformatted = 'http://[fe80:0:0:0:0:0:0:1]:/a/b?a=b#abc';
+     * const formatted = new URL(unformatted).toString();
+     *
+     * console.log(formatted); // Prints: http://[fe80::1]/a/b?a=b#abc
+     * ```
+     * @since v0.1.25
+     * @deprecated Use the WHATWG URL API instead.
+     * @param urlString A string that will be passed to `url.parse()` and then formatted.
+     */
+    function format(urlString: string): string;
     /**
      * The `url.resolve()` method resolves a target URL relative to a base URL in a
      * manner similar to that of a web browser resolving an anchor tag.
@@ -243,6 +265,8 @@ declare module "node:url" {
      * url.resolve('http://example.com/one', '/two'); // 'http://example.com/two'
      * ```
      *
+     * Because it invokes the deprecated `url.parse()` internally, `url.resolve()` is itself deprecated.
+     *
      * To achieve the same result using the WHATWG URL API:
      *
      * ```js
@@ -261,7 +285,7 @@ declare module "node:url" {
      * resolve('http://example.com/one', '/two'); // 'http://example.com/two'
      * ```
      * @since v0.1.25
-     * @legacy Use the WHATWG URL API instead.
+     * @deprecated Use the WHATWG URL API instead.
      * @param from The base URL to use if `to` is a relative URL.
      * @param to The target URL to resolve.
      */

package/dist/tedious/node_modules/@types/node/vm.d.ts

@@ -200,16 +200,16 @@ declare module "node:vm" {
          * The globals are contained in the `context` object.
          *
          * ```js
-         * import vm from 'node:vm';
+         * import { createContext, Script } from 'node:vm';
          *
          * const context = {
          *   animal: 'cat',
          *   count: 2,
          * };
          *
-         * const script = new vm.Script('count += 1; name = "kitty";');
+         * const script = new Script('count += 1; name = "kitty";');
          *
-         * vm.createContext(context);
+         * createContext(context);
          * for (let i = 0; i < 10; ++i) {
          *   script.runInContext(context);
          * }
@@ -243,9 +243,9 @@ declare module "node:vm" {
          * contained within each individual `context`.
          *
          * ```js
-         * const vm = require('node:vm');
+         * import { constants, Script } from 'node:vm';
          *
-         * const script = new vm.Script('globalVar = "set"');
+         * const script = new Script('globalVar = "set"');
          *
          * const contexts = [{}, {}, {}];
          * contexts.forEach((context) => {
@@ -256,10 +256,10 @@ declare module "node:vm" {
          * // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]
          *
          * // This would throw if the context is created from a contextified object.
-         * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary
+         * // constants.DONT_CONTEXTIFY allows creating contexts with ordinary
          * // global objects that can be frozen.
-         * const freezeScript = new vm.Script('Object.freeze(globalThis); globalThis;');
-         * const frozenContext = freezeScript.runInNewContext(vm.constants.DONT_CONTEXTIFY);
+         * const freezeScript = new Script('Object.freeze(globalThis); globalThis;');
+         * const frozenContext = freezeScript.runInNewContext(constants.DONT_CONTEXTIFY);
          * ```
          * @since v0.3.1
          * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
@@ -278,11 +278,11 @@ declare module "node:vm" {
          * executes that code multiple times:
          *
          * ```js
-         * import vm from 'node:vm';
+         * import { Script } from 'node:vm';
          *
          * global.globalVar = 0;
          *
-         * const script = new vm.Script('globalVar += 1', { filename: 'myfile.vm' });
+         * const script = new Script('globalVar += 1', { filename: 'myfile.vm' });
          *
          * for (let i = 0; i < 1000; ++i) {
          *   script.runInThisContext();
@@ -371,14 +371,14 @@ declare module "node:vm" {
      * variables will remain unchanged.
      *
      * ```js
-     * const vm = require('node:vm');
+     * import { createContext, runInContext } from 'node:vm';
      *
      * global.globalVar = 3;
      *
      * const context = { globalVar: 1 };
-     * vm.createContext(context);
+     * createContext(context);
      *
-     * vm.runInContext('globalVar *= 2;', context);
+     * runInContext('globalVar *= 2;', context);
      *
      * console.log(context);
      * // Prints: { globalVar: 2 }
@@ -429,13 +429,13 @@ declare module "node:vm" {
      * The following example compiles and executes different scripts using a single `contextified` object:
      *
      * ```js
-     * import vm from 'node:vm';
+     * import { createContext, runInContext } from 'node:vm';
      *
      * const contextObject = { globalVar: 1 };
-     * vm.createContext(contextObject);
+     * createContext(contextObject);
      *
      * for (let i = 0; i < 10; ++i) {
-     *   vm.runInContext('globalVar *= 2;', contextObject);
+     *   runInContext('globalVar *= 2;', contextObject);
      * }
      * console.log(contextObject);
      * // Prints: { globalVar: 1024 }
@@ -466,21 +466,24 @@ declare module "node:vm" {
      * variable and sets a new one. These globals are contained in the `contextObject`.
      *
      * ```js
-     * const vm = require('node:vm');
+     * import { runInNewContext, constants } from 'node:vm';
      *
      * const contextObject = {
      *   animal: 'cat',
      *   count: 2,
      * };
      *
-     * vm.runInNewContext('count += 1; name = "kitty"', contextObject);
+     * runInNewContext('count += 1; name = "kitty"', contextObject);
      * console.log(contextObject);
      * // Prints: { animal: 'cat', count: 3, name: 'kitty' }
      *
      * // This would throw if the context is created from a contextified object.
      * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary global objects that
      * // can be frozen.
-     * const frozenContext = vm.runInNewContext('Object.freeze(globalThis); globalThis;', vm.constants.DONT_CONTEXTIFY);
+     * const frozenContext = runInNewContext(
+     *   'Object.freeze(globalThis); globalThis;',
+     *   constants.DONT_CONTEXTIFY,
+     * );
      * ```
      * @since v0.3.1
      * @param code The JavaScript code to compile and run.
@@ -504,10 +507,10 @@ declare module "node:vm" {
      * the JavaScript [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) function to run the same code:
      *
      * ```js
-     * import vm from 'node:vm';
+     * import { runInThisContext } from 'node:vm';
      * let localVar = 'initial value';
      *
-     * const vmResult = vm.runInThisContext('localVar = "vm";');
+     * const vmResult = runInThisContext('localVar = "vm";');
      * console.log(`vmResult: '${vmResult}', localVar: '${localVar}'`);
      * // Prints: vmResult: 'vm', localVar: 'initial value'
      *
@@ -519,38 +522,6 @@ declare module "node:vm" {
      * Because `vm.runInThisContext()` does not have access to the local scope, `localVar` is unchanged. In contrast,
      * [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) _does_ have access to the
      * local scope, so the value `localVar` is changed. In this way `vm.runInThisContext()` is much like an [indirect `eval()` call](https://es5.github.io/#x10.4.2), e.g.`(0,eval)('code')`.
-     *
-     * ## Example: Running an HTTP server within a VM
-     *
-     * When using either `script.runInThisContext()` or {@link runInThisContext}, the code is executed within the current V8 global
-     * context. The code passed to this VM context will have its own isolated scope.
-     *
-     * In order to run a simple web server using the `node:http` module the code passed
-     * to the context must either import `node:http` on its own, or have a
-     * reference to the `node:http` module passed to it. For instance:
-     *
-     * ```js
-     * 'use strict';
-     * import vm from 'node:vm';
-     *
-     * const code = `
-     * ((require) => {
-     * const http = require('node:http');
-     *
-     *   http.createServer((request, response) => {
-     *     response.writeHead(200, { 'Content-Type': 'text/plain' });
-     *     response.end('Hello World\\n');
-     *   }).listen(8124);
-     *
-     *   console.log('Server running at http://127.0.0.1:8124/');
-     * })`;
-     *
-     * vm.runInThisContext(code)(require);
-     * ```
-     *
-     * The `require()` in the above case shares the state with the context it is
-     * passed from. This may introduce risks when untrusted code is executed, e.g.
-     * altering objects in the context in unwanted ways.
      * @since v0.3.1
      * @param code The JavaScript code to compile and run.
      * @return the result of the very last statement executed in the script.
@@ -582,44 +553,32 @@ declare module "node:vm" {
      * the memory occupied by each heap space in the current V8 instance.
      *
      * ```js
-     * import vm from 'node:vm';
+     * import { createContext, measureMemory } from 'node:vm';
      * // Measure the memory used by the main context.
-     * vm.measureMemory({ mode: 'summary' })
+     * measureMemory({ mode: 'summary' })
      *   // This is the same as vm.measureMemory()
      *   .then((result) => {
      *     // The current format is:
      *     // {
-     *     //   total: {
-     *     //      jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]
-     *     //    }
+     *     //   total: { jsMemoryEstimate: 1601828, jsMemoryRange: [1601828, 5275288] },
+     *     //   WebAssembly: { code: 0, metadata: 33962 },
      *     // }
      *     console.log(result);
      *   });
      *
-     * const context = vm.createContext({ a: 1 });
-     * vm.measureMemory({ mode: 'detailed', execution: 'eager' })
-     *   .then((result) => {
-     *     // Reference the context here so that it won't be GC'ed
-     *     // until the measurement is complete.
-     *     console.log(context.a);
-     *     // {
-     *     //   total: {
-     *     //     jsMemoryEstimate: 2574732,
-     *     //     jsMemoryRange: [ 2574732, 2904372 ]
-     *     //   },
-     *     //   current: {
-     *     //     jsMemoryEstimate: 2438996,
-     *     //     jsMemoryRange: [ 2438996, 2768636 ]
-     *     //   },
-     *     //   other: [
-     *     //     {
-     *     //       jsMemoryEstimate: 135736,
-     *     //       jsMemoryRange: [ 135736, 465376 ]
-     *     //     }
-     *     //   ]
-     *     // }
-     *     console.log(result);
-     *   });
+     * const context = createContext({ a: 1 });
+     * measureMemory({ mode: 'detailed', execution: 'eager' }).then((result) => {
+     *   // Reference the context here so that it won't be GC'ed
+     *   // until the measurement is complete.
+     *   console.log('Context:', context.a);
+     *   // {
+     *   //   total: { jsMemoryEstimate: 1767100, jsMemoryRange: [1767100, 5440560] },
+     *   //   WebAssembly: { code: 0, metadata: 33962 },
+     *   //   current: { jsMemoryEstimate: 1601828, jsMemoryRange: [1601828, 5275288] },
+     *   //   other: [{ jsMemoryEstimate: 165272, jsMemoryRange: [Array] }],
+     *   // }
+     *   console.log(result);
+     * });
      * ```
      * @since v13.10.0
      * @experimental
@@ -1092,15 +1051,21 @@ declare module "node:vm" {
      * module graphs.
      *
      * ```js
-     * import vm from 'node:vm';
+     * import { SyntheticModule } from 'node:vm';
      *
      * const source = '{ "a": 1 }';
-     * const module = new vm.SyntheticModule(['default'], function() {
+     * const syntheticModule = new SyntheticModule(['default'], function() {
      *   const obj = JSON.parse(source);
      *   this.setExport('default', obj);
      * });
      *
-     * // Use `module` in linking...
+     * // Use `syntheticModule` in linking
+     * (async () => {
+     *   await syntheticModule.link(() => {});
+     *   await syntheticModule.evaluate();
+     *
+     *   console.log('Default export:', syntheticModule.namespace.default);
+     * })();
      * ```
      * @since v13.0.0, v12.16.0
      * @experimental

package/dist/tedious/node_modules/undici-types/client.d.ts

@@ -102,6 +102,11 @@ export declare namespace Client {
      * @default 524288
      */
     connectionWindowSize?: number;
+    /**
+     * @description Time interval between PING frames dispatch
+     * @default 60000
+     */
+    pingInterval?: number;
   }
   export interface SocketInfo {
     localAddress?: string

package/dist/tedious/node_modules/undici-types/connector.d.ts

@@ -13,6 +13,7 @@ declare namespace buildConnector {
     port?: number;
     keepAlive?: boolean | null;
     keepAliveInitialDelay?: number | null;
+    typeOfService?: number | null;
   }
 
   export interface Options {
@@ -22,6 +23,7 @@ declare namespace buildConnector {
     port: string
     servername?: string
     localAddress?: string | null
+    socketPath?: string | null
     httpSocket?: Socket
   }