sql-dashboard 1.0.0

package/dist/open-T3PIT3AO.js

@@ -0,0 +1,602 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkOQJUWTZVjs = require('./chunk-OQJUWTZV.js');
+
+// node_modules/is-docker/index.js
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+function hasDockerEnv() {
+  try {
+    _fs2.default.statSync("/.dockerenv");
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return _fs2.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch (e2) {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+var isDockerCached;
+var init_is_docker = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/is-docker/index.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/is-inside-container/index.js
+
+function isInsideContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+var cachedResult, hasContainerEnv;
+var init_is_inside_container = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/is-inside-container/index.js"() {
+    "use strict";
+    init_is_docker();
+    hasContainerEnv = () => {
+      try {
+        _fs2.default.statSync("/run/.containerenv");
+        return true;
+      } catch (e3) {
+        return false;
+      }
+    };
+  }
+});
+
+// node_modules/is-wsl/index.js
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+
+var isWsl, is_wsl_default;
+var init_is_wsl = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/is-wsl/index.js"() {
+    "use strict";
+    init_is_inside_container();
+    isWsl = () => {
+      if (_process2.default.platform !== "linux") {
+        return false;
+      }
+      if (_os2.default.release().toLowerCase().includes("microsoft")) {
+        if (isInsideContainer()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        if (_fs2.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+          return !isInsideContainer();
+        }
+      } catch (e4) {
+      }
+      if (_fs2.default.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || _fs2.default.existsSync("/run/WSL")) {
+        return !isInsideContainer();
+      }
+      return false;
+    };
+    is_wsl_default = _process2.default.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+  }
+});
+
+// node_modules/wsl-utils/index.js
+
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+var wslDrivesMountPoint, powerShellPathFromWsl, powerShellPath;
+var init_wsl_utils = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/wsl-utils/index.js"() {
+    "use strict";
+    init_is_wsl();
+    init_is_wsl();
+    wslDrivesMountPoint = /* @__PURE__ */ (() => {
+      const defaultMountPoint = "/mnt/";
+      let mountPoint;
+      return async function() {
+        if (mountPoint) {
+          return mountPoint;
+        }
+        const configFilePath = "/etc/wsl.conf";
+        let isConfigFileExists = false;
+        try {
+          await _promises2.default.access(configFilePath, _promises.constants.F_OK);
+          isConfigFileExists = true;
+        } catch (e5) {
+        }
+        if (!isConfigFileExists) {
+          return defaultMountPoint;
+        }
+        const configContent = await _promises2.default.readFile(configFilePath, { encoding: "utf8" });
+        const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+        if (!configMountPoint) {
+          return defaultMountPoint;
+        }
+        mountPoint = configMountPoint.groups.mountPoint.trim();
+        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+        return mountPoint;
+      };
+    })();
+    powerShellPathFromWsl = async () => {
+      const mountPoint = await wslDrivesMountPoint();
+      return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+    };
+    powerShellPath = async () => {
+      if (is_wsl_default) {
+        return powerShellPathFromWsl();
+      }
+      return `${_process2.default.env.SYSTEMROOT || _process2.default.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+    };
+  }
+});
+
+// node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+var init_define_lazy_prop = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/define-lazy-prop/index.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/default-browser-id/index.js
+var _util = require('util');
+
+var _child_process = require('child_process'); var _child_process2 = _interopRequireDefault(_child_process);
+async function defaultBrowserId() {
+  if (_process2.default.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = _nullishCoalesce(_optionalChain([match, 'optionalAccess', _ => _.groups, 'access', _2 => _2.id]), () => ( "com.apple.Safari"));
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+var execFileAsync;
+var init_default_browser_id = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/default-browser-id/index.js"() {
+    "use strict";
+    execFileAsync = _util.promisify.call(void 0, _child_process.execFile);
+  }
+});
+
+// node_modules/run-applescript/index.js
+
+
+
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (_process2.default.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+var execFileAsync2;
+var init_run_applescript = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/run-applescript/index.js"() {
+    "use strict";
+    execFileAsync2 = _util.promisify.call(void 0, _child_process.execFile);
+  }
+});
+
+// node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+var init_bundle_name = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/bundle-name/index.js"() {
+    "use strict";
+    init_run_applescript();
+  }
+});
+
+// node_modules/default-browser/windows.js
+
+
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? void 0 : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? void 0 : id.slice(0, hyphenIndex);
+  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(windowsBrowserProgIds[id], () => ( windowsBrowserProgIds[baseIdByDot])), () => ( windowsBrowserProgIds[baseIdByHyphen])), () => ( { name: id, id }));
+}
+var execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
+var init_windows = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/default-browser/windows.js"() {
+    "use strict";
+    execFileAsync3 = _util.promisify.call(void 0, _child_process.execFile);
+    windowsBrowserProgIds = {
+      MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+      // The missing `L` is correct.
+      MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+      MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+      AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+      ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+      ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+      ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+      ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+      BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+      BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+      BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+      BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+      FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+      OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+      VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+      "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+    };
+    _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+    UnknownBrowserError = class extends Error {
+    };
+  }
+});
+
+// node_modules/default-browser/index.js
+
+
+
+async function defaultBrowser2() {
+  if (_process2.default.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (_process2.default.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (_process2.default.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+var execFileAsync4, titleize;
+var init_default_browser = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/default-browser/index.js"() {
+    "use strict";
+    init_default_browser_id();
+    init_bundle_name();
+    init_windows();
+    execFileAsync4 = _util.promisify.call(void 0, _child_process.execFile);
+    titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+  }
+});
+
+// node_modules/open/index.js
+
+var _buffer = require('buffer');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+
+
+
+async function getWindowsDefaultBrowserFromWsl() {
+  const powershellPath = await powerShellPath();
+  const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const encodedCommand = _buffer.Buffer.from(rawCommand, "utf16le").toString("base64");
+  const { stdout } = await execFile5(
+    powershellPath,
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand",
+      encodedCommand
+    ],
+    { encoding: "utf8" }
+  );
+  const progId = stdout.trim();
+  const browserMap = {
+    ChromeHTML: "com.google.chrome",
+    BraveHTML: "com.brave.Browser",
+    MSEdgeHTM: "com.microsoft.edge",
+    FirefoxURL: "org.mozilla.firefox"
+  };
+  return browserMap[progId] ? { id: browserMap[progId] } : {};
+}
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var execFile5, __dirname, localXdgOpenPath, platform, arch, pTryEach, baseOpen, open, openApp, apps, open_default;
+var init_open = _chunkOQJUWTZVjs.__esm.call(void 0, {
+  "node_modules/open/index.js"() {
+    init_wsl_utils();
+    init_define_lazy_prop();
+    init_default_browser();
+    init_is_inside_container();
+    execFile5 = _util.promisify.call(void 0, _child_process2.default.execFile);
+    __dirname = _path2.default.dirname(_url.fileURLToPath.call(void 0, import.meta.url));
+    localXdgOpenPath = _path2.default.join(__dirname, "xdg-open");
+    ({ platform, arch } = _process2.default);
+    pTryEach = async (array, mapper) => {
+      let latestError;
+      for (const item of array) {
+        try {
+          return await mapper(item);
+        } catch (error) {
+          latestError = error;
+        }
+      }
+      throw latestError;
+    };
+    baseOpen = async (options) => {
+      options = {
+        wait: false,
+        background: false,
+        newInstance: false,
+        allowNonzeroExitCode: false,
+        ...options
+      };
+      if (Array.isArray(options.app)) {
+        return pTryEach(options.app, (singleApp) => baseOpen({
+          ...options,
+          app: singleApp
+        }));
+      }
+      let { name: app, arguments: appArguments = [] } = _nullishCoalesce(options.app, () => ( {}));
+      appArguments = [...appArguments];
+      if (Array.isArray(app)) {
+        return pTryEach(app, (appName) => baseOpen({
+          ...options,
+          app: {
+            name: appName,
+            arguments: appArguments
+          }
+        }));
+      }
+      if (app === "browser" || app === "browserPrivate") {
+        const ids = {
+          "com.google.chrome": "chrome",
+          "google-chrome.desktop": "chrome",
+          "com.brave.Browser": "brave",
+          "org.mozilla.firefox": "firefox",
+          "firefox.desktop": "firefox",
+          "com.microsoft.msedge": "edge",
+          "com.microsoft.edge": "edge",
+          "com.microsoft.edgemac": "edge",
+          "microsoft-edge.desktop": "edge"
+        };
+        const flags = {
+          chrome: "--incognito",
+          brave: "--incognito",
+          firefox: "--private-window",
+          edge: "--inPrivate"
+        };
+        const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser2();
+        if (browser.id in ids) {
+          const browserName = ids[browser.id];
+          if (app === "browserPrivate") {
+            appArguments.push(flags[browserName]);
+          }
+          return baseOpen({
+            ...options,
+            app: {
+              name: apps[browserName],
+              arguments: appArguments
+            }
+          });
+        }
+        throw new Error(`${browser.name} is not supported as a default browser`);
+      }
+      let command;
+      const cliArguments = [];
+      const childProcessOptions = {};
+      if (platform === "darwin") {
+        command = "open";
+        if (options.wait) {
+          cliArguments.push("--wait-apps");
+        }
+        if (options.background) {
+          cliArguments.push("--background");
+        }
+        if (options.newInstance) {
+          cliArguments.push("--new");
+        }
+        if (app) {
+          cliArguments.push("-a", app);
+        }
+      } else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+        command = await powerShellPath();
+        cliArguments.push(
+          "-NoProfile",
+          "-NonInteractive",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-EncodedCommand"
+        );
+        if (!is_wsl_default) {
+          childProcessOptions.windowsVerbatimArguments = true;
+        }
+        const encodedArguments = ["Start"];
+        if (options.wait) {
+          encodedArguments.push("-Wait");
+        }
+        if (app) {
+          encodedArguments.push(`"\`"${app}\`""`);
+          if (options.target) {
+            appArguments.push(options.target);
+          }
+        } else if (options.target) {
+          encodedArguments.push(`"${options.target}"`);
+        }
+        if (appArguments.length > 0) {
+          appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+          encodedArguments.push("-ArgumentList", appArguments.join(","));
+        }
+        options.target = _buffer.Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+      } else {
+        if (app) {
+          command = app;
+        } else {
+          const isBundled = !__dirname || __dirname === "/";
+          let exeLocalXdgOpen = false;
+          try {
+            await _promises2.default.access(localXdgOpenPath, _promises.constants.X_OK);
+            exeLocalXdgOpen = true;
+          } catch (e6) {
+          }
+          const useSystemXdgOpen = _nullishCoalesce(_process2.default.versions.electron, () => ( (platform === "android" || isBundled || !exeLocalXdgOpen)));
+          command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+        }
+        if (appArguments.length > 0) {
+          cliArguments.push(...appArguments);
+        }
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+          childProcessOptions.detached = true;
+        }
+      }
+      if (platform === "darwin" && appArguments.length > 0) {
+        cliArguments.push("--args", ...appArguments);
+      }
+      if (options.target) {
+        cliArguments.push(options.target);
+      }
+      const subprocess = _child_process2.default.spawn(command, cliArguments, childProcessOptions);
+      if (options.wait) {
+        return new Promise((resolve, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("close", (exitCode) => {
+            if (!options.allowNonzeroExitCode && exitCode > 0) {
+              reject(new Error(`Exited with code ${exitCode}`));
+              return;
+            }
+            resolve(subprocess);
+          });
+        });
+      }
+      subprocess.unref();
+      return subprocess;
+    };
+    open = (target, options) => {
+      if (typeof target !== "string") {
+        throw new TypeError("Expected a `target`");
+      }
+      return baseOpen({
+        ...options,
+        target
+      });
+    };
+    openApp = exports.openApp = (name, options) => {
+      if (typeof name !== "string" && !Array.isArray(name)) {
+        throw new TypeError("Expected a valid `name`");
+      }
+      const { arguments: appArguments = [] } = _nullishCoalesce(options, () => ( {}));
+      if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
+        throw new TypeError("Expected `appArguments` as Array type");
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name,
+          arguments: appArguments
+        }
+      });
+    };
+    apps = exports.apps = {};
+    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+      darwin: "google chrome",
+      win32: "chrome",
+      linux: ["google-chrome", "google-chrome-stable", "chromium"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+        x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+      darwin: "brave browser",
+      win32: "brave",
+      linux: ["brave-browser", "brave"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+        x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+      darwin: "firefox",
+      win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+      linux: "firefox"
+    }, {
+      wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+    }));
+    defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+      darwin: "microsoft edge",
+      win32: "msedge",
+      linux: ["microsoft-edge", "microsoft-edge-dev"]
+    }, {
+      wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+    }));
+    defineLazyProperty(apps, "browser", () => "browser");
+    defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+    open_default = exports.default = open;
+  }
+});
+init_open();
+
+
+
+
+exports.apps = apps; exports.default = open_default; exports.openApp = openApp;

package/dist/query-BFhJHNeb.d.mts

@@ -0,0 +1,16 @@
+type QueryStatus = 'success' | 'error' | 'cancelled';
+interface QueryResult {
+    id: string;
+    status: QueryStatus;
+    rows: Record<string, unknown>[];
+    columns: string[];
+    rowCount: number;
+    affectedRows?: number;
+    duration: number;
+    query: string;
+    error?: string;
+    warning?: string;
+    insertedId?: string | number;
+}
+
+export type { QueryResult as Q };

package/dist/query-BFhJHNeb.d.ts

@@ -0,0 +1,16 @@
+type QueryStatus = 'success' | 'error' | 'cancelled';
+interface QueryResult {
+    id: string;
+    status: QueryStatus;
+    rows: Record<string, unknown>[];
+    columns: string[];
+    rowCount: number;
+    affectedRows?: number;
+    duration: number;
+    query: string;
+    error?: string;
+    warning?: string;
+    insertedId?: string | number;
+}
+
+export type { QueryResult as Q };