@dremio/js-sdk 0.47.0 → 0.49.0

package/dist-iife/cloud.js

@@ -1377,453 +1377,2361 @@ var DremioCloud = (() => {
     }
   });
 
-  // dist/cloud/index.js
-  var index_exports = {};
-  __export(index_exports, {
-    AgentChatExchange: () => AgentChatExchange,
-    AgentChatPartialResponse: () => AgentChatPartialResponse,
-    AgentChatResponse: () => AgentChatResponse,
-    AgentEndTurn: () => AgentEndTurn,
-    AgentErrorResponseContent: () => AgentErrorResponseContent,
-    AgentModelResponseContent: () => AgentModelResponseContent,
-    AgentToolCall: () => AgentToolCall,
-    AgentToolCallGroup: () => AgentToolCallGroup,
-    AgentToolRequestResponseContent: () => AgentToolRequestResponseContent,
-    AgentToolResultResponseContent: () => AgentToolResultResponseContent,
-    ChatSession: () => ChatSession,
-    ConflictResolutionStrategy: () => ConflictResolutionStrategy,
-    Dremio: () => Dremio,
-    DremioModelProvider: () => DremioModelProvider,
-    EngineRejectRule: () => EngineRejectRule,
-    EngineRouteRule: () => EngineRouteRule,
-    FileUpload: () => FileUpload,
-    FolderSearchResult: () => FolderSearchResult,
-    FunctionSearchResult: () => FunctionSearchResult,
-    Grant: () => Grant,
-    HttpError: () => HttpError,
-    JobSearchResult: () => JobSearchResult,
-    ModelProvider: () => ModelProvider,
-    Organization: () => Organization,
-    Problem: () => Problem,
-    Query: () => Query,
-    ReflectionSearchResult: () => ReflectionSearchResult,
-    ScriptSearchResult: () => ScriptSearchResult,
-    SourceSearchResult: () => SourceSearchResult,
-    SpaceSearchResult: () => SpaceSearchResult,
-    TableSearchResult: () => TableSearchResult,
-    User: () => User2,
-    UserChatMessage: () => UserChatMessage,
-    ValidationProblem: () => ValidationProblem,
-    ViewSearchResult: () => ViewSearchResult,
-    _replaceOriginResource: () => _replaceOriginResource,
-    createAuthorizationCodeUrl: () => createAuthorizationCodeUrl,
-    createConversationPromptSchema: () => createConversationPromptSchema,
-    fromAccessToken: () => fromAccessToken,
-    fromPat: () => fromPat,
-    fromRefreshToken: () => fromRefreshToken,
-    fromTextEventStream: () => fromTextEventStream,
-    fromUsernamePassword: () => fromUsernamePassword,
-    isToolRequest: () => isToolRequest,
-    isToolResult: () => isToolResult
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/constants.js
+  var require_constants = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/constants.js"(exports, module) {
+      "use strict";
+      var SEMVER_SPEC_VERSION = "2.0.0";
+      var MAX_LENGTH = 256;
+      var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+      9007199254740991;
+      var MAX_SAFE_COMPONENT_LENGTH = 16;
+      var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+      var RELEASE_TYPES = [
+        "major",
+        "premajor",
+        "minor",
+        "preminor",
+        "patch",
+        "prepatch",
+        "prerelease"
+      ];
+      module.exports = {
+        MAX_LENGTH,
+        MAX_SAFE_COMPONENT_LENGTH,
+        MAX_SAFE_BUILD_LENGTH,
+        MAX_SAFE_INTEGER,
+        RELEASE_TYPES,
+        SEMVER_SPEC_VERSION,
+        FLAG_INCLUDE_PRERELEASE: 1,
+        FLAG_LOOSE: 2
+      };
+    }
   });
 
-  // dist/cloud/Dremio.js
-  var import_moize2 = __toESM(require_moize(), 1);
-
-  // node_modules/.pnpm/ts-results-es@6.0.0/node_modules/ts-results-es/dist/esm/utils.js
-  function toString(val) {
-    var value = String(val);
-    if (value === "[object Object]") {
-      try {
-        value = JSON.stringify(val);
-      } catch (_a) {
-      }
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/debug.js
+  var require_debug = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/debug.js"(exports, module) {
+      "use strict";
+      var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+      };
+      module.exports = debug;
     }
-    return value;
-  }
+  });
 
-  // node_modules/.pnpm/ts-results-es@6.0.0/node_modules/ts-results-es/dist/esm/option.js
-  var NoneImpl = (
-    /** @class */
-    (function() {
-      function NoneImpl2() {
-      }
-      NoneImpl2.prototype.isSome = function() {
-        return false;
-      };
-      NoneImpl2.prototype.isNone = function() {
-        return true;
-      };
-      NoneImpl2.prototype[Symbol.iterator] = function() {
-        return {
-          next: function() {
-            return { done: true, value: void 0 };
-          }
-        };
-      };
-      NoneImpl2.prototype.unwrapOr = function(val) {
-        return val;
-      };
-      NoneImpl2.prototype.unwrapOrElse = function(f2) {
-        return f2();
-      };
-      NoneImpl2.prototype.expect = function(msg) {
-        throw new Error("".concat(msg));
-      };
-      NoneImpl2.prototype.unwrap = function() {
-        throw new Error("Tried to unwrap None");
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/re.js
+  var require_re = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/re.js"(exports, module) {
+      "use strict";
+      var {
+        MAX_SAFE_COMPONENT_LENGTH,
+        MAX_SAFE_BUILD_LENGTH,
+        MAX_LENGTH
+      } = require_constants();
+      var debug = require_debug();
+      exports = module.exports = {};
+      var re2 = exports.re = [];
+      var safeRe = exports.safeRe = [];
+      var src = exports.src = [];
+      var safeSrc = exports.safeSrc = [];
+      var t2 = exports.t = {};
+      var R2 = 0;
+      var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+      var safeRegexReplacements = [
+        ["\\s", 1],
+        ["\\d", MAX_LENGTH],
+        [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+      ];
+      var makeSafeRegex = (value) => {
+        for (const [token, max] of safeRegexReplacements) {
+          value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+        }
+        return value;
       };
-      NoneImpl2.prototype.map = function(_mapper) {
-        return this;
+      var createToken = (name, value, isGlobal) => {
+        const safe = makeSafeRegex(value);
+        const index = R2++;
+        debug(name, index, value);
+        t2[name] = index;
+        src[index] = value;
+        safeSrc[index] = safe;
+        re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
+        safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
       };
-      NoneImpl2.prototype.mapOr = function(default_, _mapper) {
-        return default_;
+      createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+      createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+      createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+      createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`);
+      createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`);
+      createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIER]})`);
+      createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIERLOOSE]})`);
+      createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`);
+      createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`);
+      createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+      createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`);
+      createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`);
+      createToken("FULL", `^${src[t2.FULLPLAIN]}$`);
+      createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`);
+      createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`);
+      createToken("GTLT", "((?:<|>)?=?)");
+      createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+      createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`);
+      createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`);
+      createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`);
+      createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`);
+      createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`);
+      createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+      createToken("COERCE", `${src[t2.COERCEPLAIN]}(?:$|[^\\d])`);
+      createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`);
+      createToken("COERCERTL", src[t2.COERCE], true);
+      createToken("COERCERTLFULL", src[t2.COERCEFULL], true);
+      createToken("LONETILDE", "(?:~>?)");
+      createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
+      exports.tildeTrimReplace = "$1~";
+      createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`);
+      createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`);
+      createToken("LONECARET", "(?:\\^)");
+      createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true);
+      exports.caretTrimReplace = "$1^";
+      createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`);
+      createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`);
+      createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`);
+      createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`);
+      createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true);
+      exports.comparatorTrimReplace = "$1$2$3";
+      createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`);
+      createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`);
+      createToken("STAR", "(<|>)?=?\\s*\\*");
+      createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+      createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/parse-options.js
+  var require_parse_options = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/parse-options.js"(exports, module) {
+      "use strict";
+      var looseOption = Object.freeze({ loose: true });
+      var emptyOpts = Object.freeze({});
+      var parseOptions = (options) => {
+        if (!options) {
+          return emptyOpts;
+        }
+        if (typeof options !== "object") {
+          return looseOption;
+        }
+        return options;
       };
-      NoneImpl2.prototype.mapOrElse = function(default_, _mapper) {
-        return default_();
+      module.exports = parseOptions;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/identifiers.js
+  var require_identifiers = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/identifiers.js"(exports, module) {
+      "use strict";
+      var numeric = /^[0-9]+$/;
+      var compareIdentifiers = (a2, b2) => {
+        const anum = numeric.test(a2);
+        const bnum = numeric.test(b2);
+        if (anum && bnum) {
+          a2 = +a2;
+          b2 = +b2;
+        }
+        return a2 === b2 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a2 < b2 ? -1 : 1;
       };
-      NoneImpl2.prototype.or = function(other) {
-        return other;
+      var rcompareIdentifiers = (a2, b2) => compareIdentifiers(b2, a2);
+      module.exports = {
+        compareIdentifiers,
+        rcompareIdentifiers
       };
-      NoneImpl2.prototype.orElse = function(other) {
-        return other();
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/semver.js
+  var require_semver = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/semver.js"(exports, module) {
+      "use strict";
+      var debug = require_debug();
+      var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+      var { safeRe: re2, t: t2 } = require_re();
+      var parseOptions = require_parse_options();
+      var { compareIdentifiers } = require_identifiers();
+      var SemVer = class _SemVer {
+        constructor(version2, options) {
+          options = parseOptions(options);
+          if (version2 instanceof _SemVer) {
+            if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) {
+              return version2;
+            } else {
+              version2 = version2.version;
+            }
+          } else if (typeof version2 !== "string") {
+            throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
+          }
+          if (version2.length > MAX_LENGTH) {
+            throw new TypeError(
+              `version is longer than ${MAX_LENGTH} characters`
+            );
+          }
+          debug("SemVer", version2, options);
+          this.options = options;
+          this.loose = !!options.loose;
+          this.includePrerelease = !!options.includePrerelease;
+          const m2 = version2.trim().match(options.loose ? re2[t2.LOOSE] : re2[t2.FULL]);
+          if (!m2) {
+            throw new TypeError(`Invalid Version: ${version2}`);
+          }
+          this.raw = version2;
+          this.major = +m2[1];
+          this.minor = +m2[2];
+          this.patch = +m2[3];
+          if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+            throw new TypeError("Invalid major version");
+          }
+          if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+            throw new TypeError("Invalid minor version");
+          }
+          if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+            throw new TypeError("Invalid patch version");
+          }
+          if (!m2[4]) {
+            this.prerelease = [];
+          } else {
+            this.prerelease = m2[4].split(".").map((id) => {
+              if (/^[0-9]+$/.test(id)) {
+                const num = +id;
+                if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                  return num;
+                }
+              }
+              return id;
+            });
+          }
+          this.build = m2[5] ? m2[5].split(".") : [];
+          this.format();
+        }
+        format() {
+          this.version = `${this.major}.${this.minor}.${this.patch}`;
+          if (this.prerelease.length) {
+            this.version += `-${this.prerelease.join(".")}`;
+          }
+          return this.version;
+        }
+        toString() {
+          return this.version;
+        }
+        compare(other) {
+          debug("SemVer.compare", this.version, this.options, other);
+          if (!(other instanceof _SemVer)) {
+            if (typeof other === "string" && other === this.version) {
+              return 0;
+            }
+            other = new _SemVer(other, this.options);
+          }
+          if (other.version === this.version) {
+            return 0;
+          }
+          return this.compareMain(other) || this.comparePre(other);
+        }
+        compareMain(other) {
+          if (!(other instanceof _SemVer)) {
+            other = new _SemVer(other, this.options);
+          }
+          return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+        }
+        comparePre(other) {
+          if (!(other instanceof _SemVer)) {
+            other = new _SemVer(other, this.options);
+          }
+          if (this.prerelease.length && !other.prerelease.length) {
+            return -1;
+          } else if (!this.prerelease.length && other.prerelease.length) {
+            return 1;
+          } else if (!this.prerelease.length && !other.prerelease.length) {
+            return 0;
+          }
+          let i2 = 0;
+          do {
+            const a2 = this.prerelease[i2];
+            const b2 = other.prerelease[i2];
+            debug("prerelease compare", i2, a2, b2);
+            if (a2 === void 0 && b2 === void 0) {
+              return 0;
+            } else if (b2 === void 0) {
+              return 1;
+            } else if (a2 === void 0) {
+              return -1;
+            } else if (a2 === b2) {
+              continue;
+            } else {
+              return compareIdentifiers(a2, b2);
+            }
+          } while (++i2);
+        }
+        compareBuild(other) {
+          if (!(other instanceof _SemVer)) {
+            other = new _SemVer(other, this.options);
+          }
+          let i2 = 0;
+          do {
+            const a2 = this.build[i2];
+            const b2 = other.build[i2];
+            debug("build compare", i2, a2, b2);
+            if (a2 === void 0 && b2 === void 0) {
+              return 0;
+            } else if (b2 === void 0) {
+              return 1;
+            } else if (a2 === void 0) {
+              return -1;
+            } else if (a2 === b2) {
+              continue;
+            } else {
+              return compareIdentifiers(a2, b2);
+            }
+          } while (++i2);
+        }
+        // preminor will bump the version up to the next minor release, and immediately
+        // down to pre-release. premajor and prepatch work the same way.
+        inc(release, identifier, identifierBase) {
+          if (release.startsWith("pre")) {
+            if (!identifier && identifierBase === false) {
+              throw new Error("invalid increment argument: identifier is empty");
+            }
+            if (identifier) {
+              const match = `-${identifier}`.match(this.options.loose ? re2[t2.PRERELEASELOOSE] : re2[t2.PRERELEASE]);
+              if (!match || match[1] !== identifier) {
+                throw new Error(`invalid identifier: ${identifier}`);
+              }
+            }
+          }
+          switch (release) {
+            case "premajor":
+              this.prerelease.length = 0;
+              this.patch = 0;
+              this.minor = 0;
+              this.major++;
+              this.inc("pre", identifier, identifierBase);
+              break;
+            case "preminor":
+              this.prerelease.length = 0;
+              this.patch = 0;
+              this.minor++;
+              this.inc("pre", identifier, identifierBase);
+              break;
+            case "prepatch":
+              this.prerelease.length = 0;
+              this.inc("patch", identifier, identifierBase);
+              this.inc("pre", identifier, identifierBase);
+              break;
+            // If the input is a non-prerelease version, this acts the same as
+            // prepatch.
+            case "prerelease":
+              if (this.prerelease.length === 0) {
+                this.inc("patch", identifier, identifierBase);
+              }
+              this.inc("pre", identifier, identifierBase);
+              break;
+            case "release":
+              if (this.prerelease.length === 0) {
+                throw new Error(`version ${this.raw} is not a prerelease`);
+              }
+              this.prerelease.length = 0;
+              break;
+            case "major":
+              if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+                this.major++;
+              }
+              this.minor = 0;
+              this.patch = 0;
+              this.prerelease = [];
+              break;
+            case "minor":
+              if (this.patch !== 0 || this.prerelease.length === 0) {
+                this.minor++;
+              }
+              this.patch = 0;
+              this.prerelease = [];
+              break;
+            case "patch":
+              if (this.prerelease.length === 0) {
+                this.patch++;
+              }
+              this.prerelease = [];
+              break;
+            // This probably shouldn't be used publicly.
+            // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+            case "pre": {
+              const base = Number(identifierBase) ? 1 : 0;
+              if (this.prerelease.length === 0) {
+                this.prerelease = [base];
+              } else {
+                let i2 = this.prerelease.length;
+                while (--i2 >= 0) {
+                  if (typeof this.prerelease[i2] === "number") {
+                    this.prerelease[i2]++;
+                    i2 = -2;
+                  }
+                }
+                if (i2 === -1) {
+                  if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                    throw new Error("invalid increment argument: identifier already exists");
+                  }
+                  this.prerelease.push(base);
+                }
+              }
+              if (identifier) {
+                let prerelease = [identifier, base];
+                if (identifierBase === false) {
+                  prerelease = [identifier];
+                }
+                if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                  if (isNaN(this.prerelease[1])) {
+                    this.prerelease = prerelease;
+                  }
+                } else {
+                  this.prerelease = prerelease;
+                }
+              }
+              break;
+            }
+            default:
+              throw new Error(`invalid increment argument: ${release}`);
+          }
+          this.raw = this.format();
+          if (this.build.length) {
+            this.raw += `+${this.build.join(".")}`;
+          }
+          return this;
+        }
       };
-      NoneImpl2.prototype.andThen = function(op) {
-        return this;
+      module.exports = SemVer;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/parse.js
+  var require_parse = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/parse.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var parse2 = (version2, options, throwErrors = false) => {
+        if (version2 instanceof SemVer) {
+          return version2;
+        }
+        try {
+          return new SemVer(version2, options);
+        } catch (er2) {
+          if (!throwErrors) {
+            return null;
+          }
+          throw er2;
+        }
       };
-      NoneImpl2.prototype.toResult = function(error) {
-        return Err(error);
+      module.exports = parse2;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/valid.js
+  var require_valid = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/valid.js"(exports, module) {
+      "use strict";
+      var parse2 = require_parse();
+      var valid = (version2, options) => {
+        const v2 = parse2(version2, options);
+        return v2 ? v2.version : null;
       };
-      NoneImpl2.prototype.toString = function() {
-        return "None";
+      module.exports = valid;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/clean.js
+  var require_clean = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/clean.js"(exports, module) {
+      "use strict";
+      var parse2 = require_parse();
+      var clean = (version2, options) => {
+        const s2 = parse2(version2.trim().replace(/^[=v]+/, ""), options);
+        return s2 ? s2.version : null;
       };
-      NoneImpl2.prototype.toAsyncOption = function() {
-        return new AsyncOption(None);
+      module.exports = clean;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/inc.js
+  var require_inc = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/inc.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var inc = (version2, release, options, identifier, identifierBase) => {
+        if (typeof options === "string") {
+          identifierBase = identifier;
+          identifier = options;
+          options = void 0;
+        }
+        try {
+          return new SemVer(
+            version2 instanceof SemVer ? version2.version : version2,
+            options
+          ).inc(release, identifier, identifierBase).version;
+        } catch (er2) {
+          return null;
+        }
       };
-      return NoneImpl2;
-    })()
-  );
-  var None = new NoneImpl();
-  Object.freeze(None);
-  var SomeImpl = (
-    /** @class */
-    (function() {
-      function SomeImpl2(val) {
-        if (!(this instanceof SomeImpl2)) {
-          return new SomeImpl2(val);
+      module.exports = inc;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/diff.js
+  var require_diff = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/diff.js"(exports, module) {
+      "use strict";
+      var parse2 = require_parse();
+      var diff = (version1, version2) => {
+        const v1 = parse2(version1, null, true);
+        const v2 = parse2(version2, null, true);
+        const comparison = v1.compare(v2);
+        if (comparison === 0) {
+          return null;
         }
-        this.value = val;
-      }
-      SomeImpl2.prototype.isSome = function() {
-        return true;
+        const v1Higher = comparison > 0;
+        const highVersion = v1Higher ? v1 : v2;
+        const lowVersion = v1Higher ? v2 : v1;
+        const highHasPre = !!highVersion.prerelease.length;
+        const lowHasPre = !!lowVersion.prerelease.length;
+        if (lowHasPre && !highHasPre) {
+          if (!lowVersion.patch && !lowVersion.minor) {
+            return "major";
+          }
+          if (lowVersion.compareMain(highVersion) === 0) {
+            if (lowVersion.minor && !lowVersion.patch) {
+              return "minor";
+            }
+            return "patch";
+          }
+        }
+        const prefix = highHasPre ? "pre" : "";
+        if (v1.major !== v2.major) {
+          return prefix + "major";
+        }
+        if (v1.minor !== v2.minor) {
+          return prefix + "minor";
+        }
+        if (v1.patch !== v2.patch) {
+          return prefix + "patch";
+        }
+        return "prerelease";
       };
-      SomeImpl2.prototype.isNone = function() {
-        return false;
+      module.exports = diff;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/major.js
+  var require_major = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/major.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var major = (a2, loose) => new SemVer(a2, loose).major;
+      module.exports = major;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/minor.js
+  var require_minor = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/minor.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var minor = (a2, loose) => new SemVer(a2, loose).minor;
+      module.exports = minor;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/patch.js
+  var require_patch = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/patch.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var patch = (a2, loose) => new SemVer(a2, loose).patch;
+      module.exports = patch;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/prerelease.js
+  var require_prerelease = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/prerelease.js"(exports, module) {
+      "use strict";
+      var parse2 = require_parse();
+      var prerelease = (version2, options) => {
+        const parsed = parse2(version2, options);
+        return parsed && parsed.prerelease.length ? parsed.prerelease : null;
       };
-      SomeImpl2.prototype[Symbol.iterator] = function() {
-        return [this.value][Symbol.iterator]();
+      module.exports = prerelease;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js
+  var require_compare = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var compare = (a2, b2, loose) => new SemVer(a2, loose).compare(new SemVer(b2, loose));
+      module.exports = compare;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rcompare.js
+  var require_rcompare = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rcompare.js"(exports, module) {
+      "use strict";
+      var compare = require_compare();
+      var rcompare = (a2, b2, loose) => compare(b2, a2, loose);
+      module.exports = rcompare;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-loose.js
+  var require_compare_loose = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-loose.js"(exports, module) {
+      "use strict";
+      var compare = require_compare();
+      var compareLoose = (a2, b2) => compare(a2, b2, true);
+      module.exports = compareLoose;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-build.js
+  var require_compare_build = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-build.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var compareBuild = (a2, b2, loose) => {
+        const versionA = new SemVer(a2, loose);
+        const versionB = new SemVer(b2, loose);
+        return versionA.compare(versionB) || versionA.compareBuild(versionB);
       };
-      SomeImpl2.prototype.unwrapOr = function(_val) {
-        return this.value;
+      module.exports = compareBuild;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/sort.js
+  var require_sort = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/sort.js"(exports, module) {
+      "use strict";
+      var compareBuild = require_compare_build();
+      var sort = (list, loose) => list.sort((a2, b2) => compareBuild(a2, b2, loose));
+      module.exports = sort;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rsort.js
+  var require_rsort = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rsort.js"(exports, module) {
+      "use strict";
+      var compareBuild = require_compare_build();
+      var rsort = (list, loose) => list.sort((a2, b2) => compareBuild(b2, a2, loose));
+      module.exports = rsort;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gt.js
+  var require_gt = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gt.js"(exports, module) {
+      "use strict";
+      var compare = require_compare();
+      var gt2 = (a2, b2, loose) => compare(a2, b2, loose) > 0;
+      module.exports = gt2;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lt.js
+  var require_lt = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lt.js"(exports, module) {
+      "use strict";
+      var compare = require_compare();
+      var lt2 = (a2, b2, loose) => compare(a2, b2, loose) < 0;
+      module.exports = lt2;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/eq.js
+  var require_eq = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/eq.js"(exports, module) {
+      "use strict";
+      var compare = require_compare();
+      var eq = (a2, b2, loose) => compare(a2, b2, loose) === 0;
+      module.exports = eq;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/neq.js
+  var require_neq = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/neq.js"(exports, module) {
+      "use strict";
+      var compare = require_compare();
+      var neq = (a2, b2, loose) => compare(a2, b2, loose) !== 0;
+      module.exports = neq;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js
+  var require_gte = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js"(exports, module) {
+      "use strict";
+      var compare = require_compare();
+      var gte = (a2, b2, loose) => compare(a2, b2, loose) >= 0;
+      module.exports = gte;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lte.js
+  var require_lte = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lte.js"(exports, module) {
+      "use strict";
+      var compare = require_compare();
+      var lte = (a2, b2, loose) => compare(a2, b2, loose) <= 0;
+      module.exports = lte;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/cmp.js
+  var require_cmp = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/cmp.js"(exports, module) {
+      "use strict";
+      var eq = require_eq();
+      var neq = require_neq();
+      var gt2 = require_gt();
+      var gte = require_gte();
+      var lt2 = require_lt();
+      var lte = require_lte();
+      var cmp = (a2, op, b2, loose) => {
+        switch (op) {
+          case "===":
+            if (typeof a2 === "object") {
+              a2 = a2.version;
+            }
+            if (typeof b2 === "object") {
+              b2 = b2.version;
+            }
+            return a2 === b2;
+          case "!==":
+            if (typeof a2 === "object") {
+              a2 = a2.version;
+            }
+            if (typeof b2 === "object") {
+              b2 = b2.version;
+            }
+            return a2 !== b2;
+          case "":
+          case "=":
+          case "==":
+            return eq(a2, b2, loose);
+          case "!=":
+            return neq(a2, b2, loose);
+          case ">":
+            return gt2(a2, b2, loose);
+          case ">=":
+            return gte(a2, b2, loose);
+          case "<":
+            return lt2(a2, b2, loose);
+          case "<=":
+            return lte(a2, b2, loose);
+          default:
+            throw new TypeError(`Invalid operator: ${op}`);
+        }
       };
-      SomeImpl2.prototype.unwrapOrElse = function(_f) {
-        return this.value;
+      module.exports = cmp;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/coerce.js
+  var require_coerce = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/coerce.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var parse2 = require_parse();
+      var { safeRe: re2, t: t2 } = require_re();
+      var coerce = (version2, options) => {
+        if (version2 instanceof SemVer) {
+          return version2;
+        }
+        if (typeof version2 === "number") {
+          version2 = String(version2);
+        }
+        if (typeof version2 !== "string") {
+          return null;
+        }
+        options = options || {};
+        let match = null;
+        if (!options.rtl) {
+          match = version2.match(options.includePrerelease ? re2[t2.COERCEFULL] : re2[t2.COERCE]);
+        } else {
+          const coerceRtlRegex = options.includePrerelease ? re2[t2.COERCERTLFULL] : re2[t2.COERCERTL];
+          let next;
+          while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
+            if (!match || next.index + next[0].length !== match.index + match[0].length) {
+              match = next;
+            }
+            coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+          }
+          coerceRtlRegex.lastIndex = -1;
+        }
+        if (match === null) {
+          return null;
+        }
+        const major = match[2];
+        const minor = match[3] || "0";
+        const patch = match[4] || "0";
+        const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+        const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+        return parse2(`${major}.${minor}.${patch}${prerelease}${build}`, options);
       };
-      SomeImpl2.prototype.expect = function(_msg) {
-        return this.value;
+      module.exports = coerce;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/lrucache.js
+  var require_lrucache = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/lrucache.js"(exports, module) {
+      "use strict";
+      var LRUCache = class {
+        constructor() {
+          this.max = 1e3;
+          this.map = /* @__PURE__ */ new Map();
+        }
+        get(key) {
+          const value = this.map.get(key);
+          if (value === void 0) {
+            return void 0;
+          } else {
+            this.map.delete(key);
+            this.map.set(key, value);
+            return value;
+          }
+        }
+        delete(key) {
+          return this.map.delete(key);
+        }
+        set(key, value) {
+          const deleted = this.delete(key);
+          if (!deleted && value !== void 0) {
+            if (this.map.size >= this.max) {
+              const firstKey = this.map.keys().next().value;
+              this.delete(firstKey);
+            }
+            this.map.set(key, value);
+          }
+          return this;
+        }
       };
-      SomeImpl2.prototype.unwrap = function() {
-        return this.value;
+      module.exports = LRUCache;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js
+  var require_range = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js"(exports, module) {
+      "use strict";
+      var SPACE_CHARACTERS = /\s+/g;
+      var Range = class _Range {
+        constructor(range, options) {
+          options = parseOptions(options);
+          if (range instanceof _Range) {
+            if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+              return range;
+            } else {
+              return new _Range(range.raw, options);
+            }
+          }
+          if (range instanceof Comparator) {
+            this.raw = range.value;
+            this.set = [[range]];
+            this.formatted = void 0;
+            return this;
+          }
+          this.options = options;
+          this.loose = !!options.loose;
+          this.includePrerelease = !!options.includePrerelease;
+          this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+          this.set = this.raw.split("||").map((r2) => this.parseRange(r2.trim())).filter((c2) => c2.length);
+          if (!this.set.length) {
+            throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+          }
+          if (this.set.length > 1) {
+            const first = this.set[0];
+            this.set = this.set.filter((c2) => !isNullSet(c2[0]));
+            if (this.set.length === 0) {
+              this.set = [first];
+            } else if (this.set.length > 1) {
+              for (const c2 of this.set) {
+                if (c2.length === 1 && isAny(c2[0])) {
+                  this.set = [c2];
+                  break;
+                }
+              }
+            }
+          }
+          this.formatted = void 0;
+        }
+        get range() {
+          if (this.formatted === void 0) {
+            this.formatted = "";
+            for (let i2 = 0; i2 < this.set.length; i2++) {
+              if (i2 > 0) {
+                this.formatted += "||";
+              }
+              const comps = this.set[i2];
+              for (let k2 = 0; k2 < comps.length; k2++) {
+                if (k2 > 0) {
+                  this.formatted += " ";
+                }
+                this.formatted += comps[k2].toString().trim();
+              }
+            }
+          }
+          return this.formatted;
+        }
+        format() {
+          return this.range;
+        }
+        toString() {
+          return this.range;
+        }
+        parseRange(range) {
+          const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+          const memoKey = memoOpts + ":" + range;
+          const cached2 = cache2.get(memoKey);
+          if (cached2) {
+            return cached2;
+          }
+          const loose = this.options.loose;
+          const hr2 = loose ? re2[t2.HYPHENRANGELOOSE] : re2[t2.HYPHENRANGE];
+          range = range.replace(hr2, hyphenReplace(this.options.includePrerelease));
+          debug("hyphen replace", range);
+          range = range.replace(re2[t2.COMPARATORTRIM], comparatorTrimReplace);
+          debug("comparator trim", range);
+          range = range.replace(re2[t2.TILDETRIM], tildeTrimReplace);
+          debug("tilde trim", range);
+          range = range.replace(re2[t2.CARETTRIM], caretTrimReplace);
+          debug("caret trim", range);
+          let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+          if (loose) {
+            rangeList = rangeList.filter((comp) => {
+              debug("loose invalid filter", comp, this.options);
+              return !!comp.match(re2[t2.COMPARATORLOOSE]);
+            });
+          }
+          debug("range list", rangeList);
+          const rangeMap = /* @__PURE__ */ new Map();
+          const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+          for (const comp of comparators) {
+            if (isNullSet(comp)) {
+              return [comp];
+            }
+            rangeMap.set(comp.value, comp);
+          }
+          if (rangeMap.size > 1 && rangeMap.has("")) {
+            rangeMap.delete("");
+          }
+          const result = [...rangeMap.values()];
+          cache2.set(memoKey, result);
+          return result;
+        }
+        intersects(range, options) {
+          if (!(range instanceof _Range)) {
+            throw new TypeError("a Range is required");
+          }
+          return this.set.some((thisComparators) => {
+            return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+              return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+                return rangeComparators.every((rangeComparator) => {
+                  return thisComparator.intersects(rangeComparator, options);
+                });
+              });
+            });
+          });
+        }
+        // if ANY of the sets match ALL of its comparators, then pass
+        test(version2) {
+          if (!version2) {
+            return false;
+          }
+          if (typeof version2 === "string") {
+            try {
+              version2 = new SemVer(version2, this.options);
+            } catch (er2) {
+              return false;
+            }
+          }
+          for (let i2 = 0; i2 < this.set.length; i2++) {
+            if (testSet(this.set[i2], version2, this.options)) {
+              return true;
+            }
+          }
+          return false;
+        }
       };
-      SomeImpl2.prototype.map = function(mapper) {
-        return Some(mapper(this.value));
+      module.exports = Range;
+      var LRU = require_lrucache();
+      var cache2 = new LRU();
+      var parseOptions = require_parse_options();
+      var Comparator = require_comparator();
+      var debug = require_debug();
+      var SemVer = require_semver();
+      var {
+        safeRe: re2,
+        t: t2,
+        comparatorTrimReplace,
+        tildeTrimReplace,
+        caretTrimReplace
+      } = require_re();
+      var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+      var isNullSet = (c2) => c2.value === "<0.0.0-0";
+      var isAny = (c2) => c2.value === "";
+      var isSatisfiable = (comparators, options) => {
+        let result = true;
+        const remainingComparators = comparators.slice();
+        let testComparator = remainingComparators.pop();
+        while (result && remainingComparators.length) {
+          result = remainingComparators.every((otherComparator) => {
+            return testComparator.intersects(otherComparator, options);
+          });
+          testComparator = remainingComparators.pop();
+        }
+        return result;
       };
-      SomeImpl2.prototype.mapOr = function(_default_, mapper) {
-        return mapper(this.value);
+      var parseComparator = (comp, options) => {
+        debug("comp", comp, options);
+        comp = replaceCarets(comp, options);
+        debug("caret", comp);
+        comp = replaceTildes(comp, options);
+        debug("tildes", comp);
+        comp = replaceXRanges(comp, options);
+        debug("xrange", comp);
+        comp = replaceStars(comp, options);
+        debug("stars", comp);
+        return comp;
       };
-      SomeImpl2.prototype.mapOrElse = function(_default_, mapper) {
-        return mapper(this.value);
+      var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+      var replaceTildes = (comp, options) => {
+        return comp.trim().split(/\s+/).map((c2) => replaceTilde(c2, options)).join(" ");
       };
-      SomeImpl2.prototype.or = function(_other) {
-        return this;
+      var replaceTilde = (comp, options) => {
+        const r2 = options.loose ? re2[t2.TILDELOOSE] : re2[t2.TILDE];
+        return comp.replace(r2, (_2, M2, m2, p2, pr2) => {
+          debug("tilde", comp, _2, M2, m2, p2, pr2);
+          let ret;
+          if (isX(M2)) {
+            ret = "";
+          } else if (isX(m2)) {
+            ret = `>=${M2}.0.0 <${+M2 + 1}.0.0-0`;
+          } else if (isX(p2)) {
+            ret = `>=${M2}.${m2}.0 <${M2}.${+m2 + 1}.0-0`;
+          } else if (pr2) {
+            debug("replaceTilde pr", pr2);
+            ret = `>=${M2}.${m2}.${p2}-${pr2} <${M2}.${+m2 + 1}.0-0`;
+          } else {
+            ret = `>=${M2}.${m2}.${p2} <${M2}.${+m2 + 1}.0-0`;
+          }
+          debug("tilde return", ret);
+          return ret;
+        });
       };
-      SomeImpl2.prototype.orElse = function(_other) {
-        return this;
+      var replaceCarets = (comp, options) => {
+        return comp.trim().split(/\s+/).map((c2) => replaceCaret(c2, options)).join(" ");
       };
-      SomeImpl2.prototype.andThen = function(mapper) {
-        return mapper(this.value);
+      var replaceCaret = (comp, options) => {
+        debug("caret", comp, options);
+        const r2 = options.loose ? re2[t2.CARETLOOSE] : re2[t2.CARET];
+        const z2 = options.includePrerelease ? "-0" : "";
+        return comp.replace(r2, (_2, M2, m2, p2, pr2) => {
+          debug("caret", comp, _2, M2, m2, p2, pr2);
+          let ret;
+          if (isX(M2)) {
+            ret = "";
+          } else if (isX(m2)) {
+            ret = `>=${M2}.0.0${z2} <${+M2 + 1}.0.0-0`;
+          } else if (isX(p2)) {
+            if (M2 === "0") {
+              ret = `>=${M2}.${m2}.0${z2} <${M2}.${+m2 + 1}.0-0`;
+            } else {
+              ret = `>=${M2}.${m2}.0${z2} <${+M2 + 1}.0.0-0`;
+            }
+          } else if (pr2) {
+            debug("replaceCaret pr", pr2);
+            if (M2 === "0") {
+              if (m2 === "0") {
+                ret = `>=${M2}.${m2}.${p2}-${pr2} <${M2}.${m2}.${+p2 + 1}-0`;
+              } else {
+                ret = `>=${M2}.${m2}.${p2}-${pr2} <${M2}.${+m2 + 1}.0-0`;
+              }
+            } else {
+              ret = `>=${M2}.${m2}.${p2}-${pr2} <${+M2 + 1}.0.0-0`;
+            }
+          } else {
+            debug("no pr");
+            if (M2 === "0") {
+              if (m2 === "0") {
+                ret = `>=${M2}.${m2}.${p2}${z2} <${M2}.${m2}.${+p2 + 1}-0`;
+              } else {
+                ret = `>=${M2}.${m2}.${p2}${z2} <${M2}.${+m2 + 1}.0-0`;
+              }
+            } else {
+              ret = `>=${M2}.${m2}.${p2} <${+M2 + 1}.0.0-0`;
+            }
+          }
+          debug("caret return", ret);
+          return ret;
+        });
       };
-      SomeImpl2.prototype.toResult = function(error) {
-        return Ok(this.value);
+      var replaceXRanges = (comp, options) => {
+        debug("replaceXRanges", comp, options);
+        return comp.split(/\s+/).map((c2) => replaceXRange(c2, options)).join(" ");
       };
-      SomeImpl2.prototype.toAsyncOption = function() {
-        return new AsyncOption(this);
+      var replaceXRange = (comp, options) => {
+        comp = comp.trim();
+        const r2 = options.loose ? re2[t2.XRANGELOOSE] : re2[t2.XRANGE];
+        return comp.replace(r2, (ret, gtlt, M2, m2, p2, pr2) => {
+          debug("xRange", comp, ret, gtlt, M2, m2, p2, pr2);
+          const xM = isX(M2);
+          const xm = xM || isX(m2);
+          const xp = xm || isX(p2);
+          const anyX = xp;
+          if (gtlt === "=" && anyX) {
+            gtlt = "";
+          }
+          pr2 = options.includePrerelease ? "-0" : "";
+          if (xM) {
+            if (gtlt === ">" || gtlt === "<") {
+              ret = "<0.0.0-0";
+            } else {
+              ret = "*";
+            }
+          } else if (gtlt && anyX) {
+            if (xm) {
+              m2 = 0;
+            }
+            p2 = 0;
+            if (gtlt === ">") {
+              gtlt = ">=";
+              if (xm) {
+                M2 = +M2 + 1;
+                m2 = 0;
+                p2 = 0;
+              } else {
+                m2 = +m2 + 1;
+                p2 = 0;
+              }
+            } else if (gtlt === "<=") {
+              gtlt = "<";
+              if (xm) {
+                M2 = +M2 + 1;
+              } else {
+                m2 = +m2 + 1;
+              }
+            }
+            if (gtlt === "<") {
+              pr2 = "-0";
+            }
+            ret = `${gtlt + M2}.${m2}.${p2}${pr2}`;
+          } else if (xm) {
+            ret = `>=${M2}.0.0${pr2} <${+M2 + 1}.0.0-0`;
+          } else if (xp) {
+            ret = `>=${M2}.${m2}.0${pr2} <${M2}.${+m2 + 1}.0-0`;
+          }
+          debug("xRange return", ret);
+          return ret;
+        });
       };
-      SomeImpl2.prototype.safeUnwrap = function() {
-        return this.value;
+      var replaceStars = (comp, options) => {
+        debug("replaceStars", comp, options);
+        return comp.trim().replace(re2[t2.STAR], "");
       };
-      SomeImpl2.prototype.toString = function() {
-        return "Some(".concat(toString(this.value), ")");
+      var replaceGTE0 = (comp, options) => {
+        debug("replaceGTE0", comp, options);
+        return comp.trim().replace(re2[options.includePrerelease ? t2.GTE0PRE : t2.GTE0], "");
       };
-      SomeImpl2.EMPTY = new SomeImpl2(void 0);
-      return SomeImpl2;
-    })()
-  );
-  var Some = SomeImpl;
-  var Option;
-  (function(Option2) {
-    function all() {
-      var options = [];
-      for (var _i2 = 0; _i2 < arguments.length; _i2++) {
-        options[_i2] = arguments[_i2];
-      }
-      var someOption = [];
-      for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {
-        var option = options_1[_a];
-        if (option.isSome()) {
-          someOption.push(option.value);
+      var hyphenReplace = (incPr) => ($0, from2, fM, fm, fp, fpr, fb, to2, tM, tm, tp, tpr) => {
+        if (isX(fM)) {
+          from2 = "";
+        } else if (isX(fm)) {
+          from2 = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+        } else if (isX(fp)) {
+          from2 = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+        } else if (fpr) {
+          from2 = `>=${from2}`;
         } else {
-          return option;
-        }
-      }
-      return Some(someOption);
-    }
-    Option2.all = all;
-    function any() {
-      var options = [];
-      for (var _i2 = 0; _i2 < arguments.length; _i2++) {
-        options[_i2] = arguments[_i2];
-      }
-      for (var _a = 0, options_2 = options; _a < options_2.length; _a++) {
-        var option = options_2[_a];
-        if (option.isSome()) {
-          return option;
+          from2 = `>=${from2}${incPr ? "-0" : ""}`;
+        }
+        if (isX(tM)) {
+          to2 = "";
+        } else if (isX(tm)) {
+          to2 = `<${+tM + 1}.0.0-0`;
+        } else if (isX(tp)) {
+          to2 = `<${tM}.${+tm + 1}.0-0`;
+        } else if (tpr) {
+          to2 = `<=${tM}.${tm}.${tp}-${tpr}`;
+        } else if (incPr) {
+          to2 = `<${tM}.${tm}.${+tp + 1}-0`;
         } else {
-          continue;
+          to2 = `<=${to2}`;
         }
-      }
-      return None;
-    }
-    Option2.any = any;
-    function isOption(value) {
-      return value instanceof Some || value === None;
-    }
-    Option2.isOption = isOption;
-  })(Option || (Option = {}));
-
-  // node_modules/.pnpm/ts-results-es@6.0.0/node_modules/ts-results-es/dist/esm/result.js
-  var __spreadArray = function(to2, from2, pack) {
-    if (pack || arguments.length === 2) for (var i2 = 0, l2 = from2.length, ar2; i2 < l2; i2++) {
-      if (ar2 || !(i2 in from2)) {
-        if (!ar2) ar2 = Array.prototype.slice.call(from2, 0, i2);
-        ar2[i2] = from2[i2];
-      }
-    }
-    return to2.concat(ar2 || Array.prototype.slice.call(from2));
-  };
-  var ErrImpl = (
-    /** @class */
-    (function() {
-      function ErrImpl2(val) {
-        if (!(this instanceof ErrImpl2)) {
-          return new ErrImpl2(val);
+        return `${from2} ${to2}`.trim();
+      };
+      var testSet = (set3, version2, options) => {
+        for (let i2 = 0; i2 < set3.length; i2++) {
+          if (!set3[i2].test(version2)) {
+            return false;
+          }
         }
-        this.error = val;
-        var stackLines = new Error().stack.split("\n").slice(2);
-        if (stackLines && stackLines.length > 0 && stackLines[0].includes("ErrImpl")) {
-          stackLines.shift();
+        if (version2.prerelease.length && !options.includePrerelease) {
+          for (let i2 = 0; i2 < set3.length; i2++) {
+            debug(set3[i2].semver);
+            if (set3[i2].semver === Comparator.ANY) {
+              continue;
+            }
+            if (set3[i2].semver.prerelease.length > 0) {
+              const allowed = set3[i2].semver;
+              if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
+                return true;
+              }
+            }
+          }
+          return false;
         }
-        this._stack = stackLines.join("\n");
-      }
-      ErrImpl2.prototype.isOk = function() {
-        return false;
-      };
-      ErrImpl2.prototype.isErr = function() {
         return true;
       };
-      ErrImpl2.prototype[Symbol.iterator] = function() {
-        return {
-          next: function() {
-            return { done: true, value: void 0 };
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js
+  var require_comparator = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js"(exports, module) {
+      "use strict";
+      var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
+      var Comparator = class _Comparator {
+        static get ANY() {
+          return ANY;
+        }
+        constructor(comp, options) {
+          options = parseOptions(options);
+          if (comp instanceof _Comparator) {
+            if (comp.loose === !!options.loose) {
+              return comp;
+            } else {
+              comp = comp.value;
+            }
           }
-        };
-      };
-      ErrImpl2.prototype.else = function(val) {
-        return val;
-      };
-      ErrImpl2.prototype.unwrapOr = function(val) {
-        return val;
-      };
-      ErrImpl2.prototype.unwrapOrElse = function(f2) {
-        return f2(this.error);
-      };
-      ErrImpl2.prototype.expect = function(msg) {
-        throw new Error("".concat(msg, " - Error: ").concat(toString(this.error), "\n").concat(this._stack), { cause: this.error });
-      };
-      ErrImpl2.prototype.expectErr = function(_msg) {
-        return this.error;
-      };
-      ErrImpl2.prototype.unwrap = function() {
-        throw new Error("Tried to unwrap Error: ".concat(toString(this.error), "\n").concat(this._stack), { cause: this.error });
-      };
-      ErrImpl2.prototype.unwrapErr = function() {
-        return this.error;
-      };
-      ErrImpl2.prototype.map = function(_mapper) {
-        return this;
-      };
-      ErrImpl2.prototype.andThen = function(op) {
-        return this;
+          comp = comp.trim().split(/\s+/).join(" ");
+          debug("comparator", comp, options);
+          this.options = options;
+          this.loose = !!options.loose;
+          this.parse(comp);
+          if (this.semver === ANY) {
+            this.value = "";
+          } else {
+            this.value = this.operator + this.semver.version;
+          }
+          debug("comp", this);
+        }
+        parse(comp) {
+          const r2 = this.options.loose ? re2[t2.COMPARATORLOOSE] : re2[t2.COMPARATOR];
+          const m2 = comp.match(r2);
+          if (!m2) {
+            throw new TypeError(`Invalid comparator: ${comp}`);
+          }
+          this.operator = m2[1] !== void 0 ? m2[1] : "";
+          if (this.operator === "=") {
+            this.operator = "";
+          }
+          if (!m2[2]) {
+            this.semver = ANY;
+          } else {
+            this.semver = new SemVer(m2[2], this.options.loose);
+          }
+        }
+        toString() {
+          return this.value;
+        }
+        test(version2) {
+          debug("Comparator.test", version2, this.options.loose);
+          if (this.semver === ANY || version2 === ANY) {
+            return true;
+          }
+          if (typeof version2 === "string") {
+            try {
+              version2 = new SemVer(version2, this.options);
+            } catch (er2) {
+              return false;
+            }
+          }
+          return cmp(version2, this.operator, this.semver, this.options);
+        }
+        intersects(comp, options) {
+          if (!(comp instanceof _Comparator)) {
+            throw new TypeError("a Comparator is required");
+          }
+          if (this.operator === "") {
+            if (this.value === "") {
+              return true;
+            }
+            return new Range(comp.value, options).test(this.value);
+          } else if (comp.operator === "") {
+            if (comp.value === "") {
+              return true;
+            }
+            return new Range(this.value, options).test(comp.semver);
+          }
+          options = parseOptions(options);
+          if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+            return false;
+          }
+          if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+            return false;
+          }
+          if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+            return true;
+          }
+          if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+            return true;
+          }
+          if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+            return true;
+          }
+          if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+            return true;
+          }
+          if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+            return true;
+          }
+          return false;
+        }
       };
-      ErrImpl2.prototype.mapErr = function(mapper) {
-        return new Err(mapper(this.error));
+      module.exports = Comparator;
+      var parseOptions = require_parse_options();
+      var { safeRe: re2, t: t2 } = require_re();
+      var cmp = require_cmp();
+      var debug = require_debug();
+      var SemVer = require_semver();
+      var Range = require_range();
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/satisfies.js
+  var require_satisfies = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/satisfies.js"(exports, module) {
+      "use strict";
+      var Range = require_range();
+      var satisfies = (version2, range, options) => {
+        try {
+          range = new Range(range, options);
+        } catch (er2) {
+          return false;
+        }
+        return range.test(version2);
       };
-      ErrImpl2.prototype.mapOr = function(default_, _mapper) {
-        return default_;
+      module.exports = satisfies;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/to-comparators.js
+  var require_to_comparators = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/to-comparators.js"(exports, module) {
+      "use strict";
+      var Range = require_range();
+      var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c2) => c2.value).join(" ").trim().split(" "));
+      module.exports = toComparators;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/max-satisfying.js
+  var require_max_satisfying = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/max-satisfying.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var Range = require_range();
+      var maxSatisfying = (versions, range, options) => {
+        let max = null;
+        let maxSV = null;
+        let rangeObj = null;
+        try {
+          rangeObj = new Range(range, options);
+        } catch (er2) {
+          return null;
+        }
+        versions.forEach((v2) => {
+          if (rangeObj.test(v2)) {
+            if (!max || maxSV.compare(v2) === -1) {
+              max = v2;
+              maxSV = new SemVer(max, options);
+            }
+          }
+        });
+        return max;
       };
-      ErrImpl2.prototype.mapOrElse = function(default_, _mapper) {
-        return default_(this.error);
+      module.exports = maxSatisfying;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-satisfying.js
+  var require_min_satisfying = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-satisfying.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var Range = require_range();
+      var minSatisfying = (versions, range, options) => {
+        let min = null;
+        let minSV = null;
+        let rangeObj = null;
+        try {
+          rangeObj = new Range(range, options);
+        } catch (er2) {
+          return null;
+        }
+        versions.forEach((v2) => {
+          if (rangeObj.test(v2)) {
+            if (!min || minSV.compare(v2) === 1) {
+              min = v2;
+              minSV = new SemVer(min, options);
+            }
+          }
+        });
+        return min;
       };
-      ErrImpl2.prototype.or = function(other) {
-        return other;
+      module.exports = minSatisfying;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-version.js
+  var require_min_version = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-version.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var Range = require_range();
+      var gt2 = require_gt();
+      var minVersion = (range, loose) => {
+        range = new Range(range, loose);
+        let minver = new SemVer("0.0.0");
+        if (range.test(minver)) {
+          return minver;
+        }
+        minver = new SemVer("0.0.0-0");
+        if (range.test(minver)) {
+          return minver;
+        }
+        minver = null;
+        for (let i2 = 0; i2 < range.set.length; ++i2) {
+          const comparators = range.set[i2];
+          let setMin = null;
+          comparators.forEach((comparator) => {
+            const compver = new SemVer(comparator.semver.version);
+            switch (comparator.operator) {
+              case ">":
+                if (compver.prerelease.length === 0) {
+                  compver.patch++;
+                } else {
+                  compver.prerelease.push(0);
+                }
+                compver.raw = compver.format();
+              /* fallthrough */
+              case "":
+              case ">=":
+                if (!setMin || gt2(compver, setMin)) {
+                  setMin = compver;
+                }
+                break;
+              case "<":
+              case "<=":
+                break;
+              /* istanbul ignore next */
+              default:
+                throw new Error(`Unexpected operation: ${comparator.operator}`);
+            }
+          });
+          if (setMin && (!minver || gt2(minver, setMin))) {
+            minver = setMin;
+          }
+        }
+        if (minver && range.test(minver)) {
+          return minver;
+        }
+        return null;
       };
-      ErrImpl2.prototype.orElse = function(other) {
-        return other(this.error);
+      module.exports = minVersion;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/valid.js
+  var require_valid2 = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/valid.js"(exports, module) {
+      "use strict";
+      var Range = require_range();
+      var validRange = (range, options) => {
+        try {
+          return new Range(range, options).range || "*";
+        } catch (er2) {
+          return null;
+        }
       };
-      ErrImpl2.prototype.toOption = function() {
-        return None;
+      module.exports = validRange;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/outside.js
+  var require_outside = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/outside.js"(exports, module) {
+      "use strict";
+      var SemVer = require_semver();
+      var Comparator = require_comparator();
+      var { ANY } = Comparator;
+      var Range = require_range();
+      var satisfies = require_satisfies();
+      var gt2 = require_gt();
+      var lt2 = require_lt();
+      var lte = require_lte();
+      var gte = require_gte();
+      var outside = (version2, range, hilo, options) => {
+        version2 = new SemVer(version2, options);
+        range = new Range(range, options);
+        let gtfn, ltefn, ltfn, comp, ecomp;
+        switch (hilo) {
+          case ">":
+            gtfn = gt2;
+            ltefn = lte;
+            ltfn = lt2;
+            comp = ">";
+            ecomp = ">=";
+            break;
+          case "<":
+            gtfn = lt2;
+            ltefn = gte;
+            ltfn = gt2;
+            comp = "<";
+            ecomp = "<=";
+            break;
+          default:
+            throw new TypeError('Must provide a hilo val of "<" or ">"');
+        }
+        if (satisfies(version2, range, options)) {
+          return false;
+        }
+        for (let i2 = 0; i2 < range.set.length; ++i2) {
+          const comparators = range.set[i2];
+          let high = null;
+          let low = null;
+          comparators.forEach((comparator) => {
+            if (comparator.semver === ANY) {
+              comparator = new Comparator(">=0.0.0");
+            }
+            high = high || comparator;
+            low = low || comparator;
+            if (gtfn(comparator.semver, high.semver, options)) {
+              high = comparator;
+            } else if (ltfn(comparator.semver, low.semver, options)) {
+              low = comparator;
+            }
+          });
+          if (high.operator === comp || high.operator === ecomp) {
+            return false;
+          }
+          if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
+            return false;
+          } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
+            return false;
+          }
+        }
+        return true;
       };
-      ErrImpl2.prototype.toString = function() {
-        return "Err(".concat(toString(this.error), ")");
+      module.exports = outside;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/gtr.js
+  var require_gtr = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/gtr.js"(exports, module) {
+      "use strict";
+      var outside = require_outside();
+      var gtr = (version2, range, options) => outside(version2, range, ">", options);
+      module.exports = gtr;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/ltr.js
+  var require_ltr = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/ltr.js"(exports, module) {
+      "use strict";
+      var outside = require_outside();
+      var ltr = (version2, range, options) => outside(version2, range, "<", options);
+      module.exports = ltr;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/intersects.js
+  var require_intersects = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/intersects.js"(exports, module) {
+      "use strict";
+      var Range = require_range();
+      var intersects = (r1, r2, options) => {
+        r1 = new Range(r1, options);
+        r2 = new Range(r2, options);
+        return r1.intersects(r2, options);
       };
-      Object.defineProperty(ErrImpl2.prototype, "stack", {
-        get: function() {
-          return "".concat(this, "\n").concat(this._stack);
-        },
-        enumerable: false,
-        configurable: true
-      });
-      ErrImpl2.prototype.toAsyncResult = function() {
-        return new AsyncResult(this);
+      module.exports = intersects;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/simplify.js
+  var require_simplify = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/simplify.js"(exports, module) {
+      "use strict";
+      var satisfies = require_satisfies();
+      var compare = require_compare();
+      module.exports = (versions, range, options) => {
+        const set3 = [];
+        let first = null;
+        let prev = null;
+        const v2 = versions.sort((a2, b2) => compare(a2, b2, options));
+        for (const version2 of v2) {
+          const included = satisfies(version2, range, options);
+          if (included) {
+            prev = version2;
+            if (!first) {
+              first = version2;
+            }
+          } else {
+            if (prev) {
+              set3.push([first, prev]);
+            }
+            prev = null;
+            first = null;
+          }
+        }
+        if (first) {
+          set3.push([first, null]);
+        }
+        const ranges = [];
+        for (const [min, max] of set3) {
+          if (min === max) {
+            ranges.push(min);
+          } else if (!max && min === v2[0]) {
+            ranges.push("*");
+          } else if (!max) {
+            ranges.push(`>=${min}`);
+          } else if (min === v2[0]) {
+            ranges.push(`<=${max}`);
+          } else {
+            ranges.push(`${min} - ${max}`);
+          }
+        }
+        const simplified = ranges.join(" || ");
+        const original = typeof range.raw === "string" ? range.raw : String(range);
+        return simplified.length < original.length ? simplified : range;
       };
-      ErrImpl2.EMPTY = new ErrImpl2(void 0);
-      return ErrImpl2;
-    })()
-  );
-  var Err = ErrImpl;
-  var OkImpl = (
-    /** @class */
-    (function() {
-      function OkImpl2(val) {
-        if (!(this instanceof OkImpl2)) {
-          return new OkImpl2(val);
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/subset.js
+  var require_subset = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/subset.js"(exports, module) {
+      "use strict";
+      var Range = require_range();
+      var Comparator = require_comparator();
+      var { ANY } = Comparator;
+      var satisfies = require_satisfies();
+      var compare = require_compare();
+      var subset = (sub, dom, options = {}) => {
+        if (sub === dom) {
+          return true;
+        }
+        sub = new Range(sub, options);
+        dom = new Range(dom, options);
+        let sawNonNull = false;
+        OUTER: for (const simpleSub of sub.set) {
+          for (const simpleDom of dom.set) {
+            const isSub = simpleSubset(simpleSub, simpleDom, options);
+            sawNonNull = sawNonNull || isSub !== null;
+            if (isSub) {
+              continue OUTER;
+            }
+          }
+          if (sawNonNull) {
+            return false;
+          }
         }
-        this.value = val;
-      }
-      OkImpl2.prototype.isOk = function() {
         return true;
       };
-      OkImpl2.prototype.isErr = function() {
-        return false;
-      };
-      OkImpl2.prototype[Symbol.iterator] = function() {
-        return [this.value][Symbol.iterator]();
-      };
-      OkImpl2.prototype.else = function(_val) {
-        return this.value;
+      var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+      var minimumVersion = [new Comparator(">=0.0.0")];
+      var simpleSubset = (sub, dom, options) => {
+        if (sub === dom) {
+          return true;
+        }
+        if (sub.length === 1 && sub[0].semver === ANY) {
+          if (dom.length === 1 && dom[0].semver === ANY) {
+            return true;
+          } else if (options.includePrerelease) {
+            sub = minimumVersionWithPreRelease;
+          } else {
+            sub = minimumVersion;
+          }
+        }
+        if (dom.length === 1 && dom[0].semver === ANY) {
+          if (options.includePrerelease) {
+            return true;
+          } else {
+            dom = minimumVersion;
+          }
+        }
+        const eqSet = /* @__PURE__ */ new Set();
+        let gt2, lt2;
+        for (const c2 of sub) {
+          if (c2.operator === ">" || c2.operator === ">=") {
+            gt2 = higherGT(gt2, c2, options);
+          } else if (c2.operator === "<" || c2.operator === "<=") {
+            lt2 = lowerLT(lt2, c2, options);
+          } else {
+            eqSet.add(c2.semver);
+          }
+        }
+        if (eqSet.size > 1) {
+          return null;
+        }
+        let gtltComp;
+        if (gt2 && lt2) {
+          gtltComp = compare(gt2.semver, lt2.semver, options);
+          if (gtltComp > 0) {
+            return null;
+          } else if (gtltComp === 0 && (gt2.operator !== ">=" || lt2.operator !== "<=")) {
+            return null;
+          }
+        }
+        for (const eq of eqSet) {
+          if (gt2 && !satisfies(eq, String(gt2), options)) {
+            return null;
+          }
+          if (lt2 && !satisfies(eq, String(lt2), options)) {
+            return null;
+          }
+          for (const c2 of dom) {
+            if (!satisfies(eq, String(c2), options)) {
+              return false;
+            }
+          }
+          return true;
+        }
+        let higher, lower;
+        let hasDomLT, hasDomGT;
+        let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false;
+        let needDomGTPre = gt2 && !options.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false;
+        if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+          needDomLTPre = false;
+        }
+        for (const c2 of dom) {
+          hasDomGT = hasDomGT || c2.operator === ">" || c2.operator === ">=";
+          hasDomLT = hasDomLT || c2.operator === "<" || c2.operator === "<=";
+          if (gt2) {
+            if (needDomGTPre) {
+              if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomGTPre.major && c2.semver.minor === needDomGTPre.minor && c2.semver.patch === needDomGTPre.patch) {
+                needDomGTPre = false;
+              }
+            }
+            if (c2.operator === ">" || c2.operator === ">=") {
+              higher = higherGT(gt2, c2, options);
+              if (higher === c2 && higher !== gt2) {
+                return false;
+              }
+            } else if (gt2.operator === ">=" && !satisfies(gt2.semver, String(c2), options)) {
+              return false;
+            }
+          }
+          if (lt2) {
+            if (needDomLTPre) {
+              if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomLTPre.major && c2.semver.minor === needDomLTPre.minor && c2.semver.patch === needDomLTPre.patch) {
+                needDomLTPre = false;
+              }
+            }
+            if (c2.operator === "<" || c2.operator === "<=") {
+              lower = lowerLT(lt2, c2, options);
+              if (lower === c2 && lower !== lt2) {
+                return false;
+              }
+            } else if (lt2.operator === "<=" && !satisfies(lt2.semver, String(c2), options)) {
+              return false;
+            }
+          }
+          if (!c2.operator && (lt2 || gt2) && gtltComp !== 0) {
+            return false;
+          }
+        }
+        if (gt2 && hasDomLT && !lt2 && gtltComp !== 0) {
+          return false;
+        }
+        if (lt2 && hasDomGT && !gt2 && gtltComp !== 0) {
+          return false;
+        }
+        if (needDomGTPre || needDomLTPre) {
+          return false;
+        }
+        return true;
       };
-      OkImpl2.prototype.unwrapOr = function(_val) {
-        return this.value;
+      var higherGT = (a2, b2, options) => {
+        if (!a2) {
+          return b2;
+        }
+        const comp = compare(a2.semver, b2.semver, options);
+        return comp > 0 ? a2 : comp < 0 ? b2 : b2.operator === ">" && a2.operator === ">=" ? b2 : a2;
       };
-      OkImpl2.prototype.unwrapOrElse = function(_f) {
-        return this.value;
+      var lowerLT = (a2, b2, options) => {
+        if (!a2) {
+          return b2;
+        }
+        const comp = compare(a2.semver, b2.semver, options);
+        return comp < 0 ? a2 : comp > 0 ? b2 : b2.operator === "<" && a2.operator === "<=" ? b2 : a2;
       };
-      OkImpl2.prototype.expect = function(_msg) {
-        return this.value;
+      module.exports = subset;
+    }
+  });
+
+  // node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js
+  var require_semver2 = __commonJS({
+    "node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js"(exports, module) {
+      "use strict";
+      var internalRe = require_re();
+      var constants = require_constants();
+      var SemVer = require_semver();
+      var identifiers = require_identifiers();
+      var parse2 = require_parse();
+      var valid = require_valid();
+      var clean = require_clean();
+      var inc = require_inc();
+      var diff = require_diff();
+      var major = require_major();
+      var minor = require_minor();
+      var patch = require_patch();
+      var prerelease = require_prerelease();
+      var compare = require_compare();
+      var rcompare = require_rcompare();
+      var compareLoose = require_compare_loose();
+      var compareBuild = require_compare_build();
+      var sort = require_sort();
+      var rsort = require_rsort();
+      var gt2 = require_gt();
+      var lt2 = require_lt();
+      var eq = require_eq();
+      var neq = require_neq();
+      var gte = require_gte();
+      var lte = require_lte();
+      var cmp = require_cmp();
+      var coerce = require_coerce();
+      var Comparator = require_comparator();
+      var Range = require_range();
+      var satisfies = require_satisfies();
+      var toComparators = require_to_comparators();
+      var maxSatisfying = require_max_satisfying();
+      var minSatisfying = require_min_satisfying();
+      var minVersion = require_min_version();
+      var validRange = require_valid2();
+      var outside = require_outside();
+      var gtr = require_gtr();
+      var ltr = require_ltr();
+      var intersects = require_intersects();
+      var simplifyRange = require_simplify();
+      var subset = require_subset();
+      module.exports = {
+        parse: parse2,
+        valid,
+        clean,
+        inc,
+        diff,
+        major,
+        minor,
+        patch,
+        prerelease,
+        compare,
+        rcompare,
+        compareLoose,
+        compareBuild,
+        sort,
+        rsort,
+        gt: gt2,
+        lt: lt2,
+        eq,
+        neq,
+        gte,
+        lte,
+        cmp,
+        coerce,
+        Comparator,
+        Range,
+        satisfies,
+        toComparators,
+        maxSatisfying,
+        minSatisfying,
+        minVersion,
+        validRange,
+        outside,
+        gtr,
+        ltr,
+        intersects,
+        simplifyRange,
+        subset,
+        SemVer,
+        re: internalRe.re,
+        src: internalRe.src,
+        tokens: internalRe.t,
+        SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+        RELEASE_TYPES: constants.RELEASE_TYPES,
+        compareIdentifiers: identifiers.compareIdentifiers,
+        rcompareIdentifiers: identifiers.rcompareIdentifiers
       };
-      OkImpl2.prototype.expectErr = function(msg) {
-        throw new Error(msg);
+    }
+  });
+
+  // dist/cloud/index.js
+  var index_exports = {};
+  __export(index_exports, {
+    AgentChatExchange: () => AgentChatExchange,
+    AgentChatPartialResponse: () => AgentChatPartialResponse,
+    AgentChatResponse: () => AgentChatResponse,
+    AgentEndTurn: () => AgentEndTurn,
+    AgentErrorResponseContent: () => AgentErrorResponseContent,
+    AgentModelResponseContent: () => AgentModelResponseContent,
+    AgentToolCall: () => AgentToolCall,
+    AgentToolCallGroup: () => AgentToolCallGroup,
+    AgentToolRequestResponseContent: () => AgentToolRequestResponseContent,
+    AgentToolResultResponseContent: () => AgentToolResultResponseContent,
+    ChatSession: () => ChatSession,
+    ConflictResolutionStrategy: () => ConflictResolutionStrategy,
+    Dremio: () => Dremio,
+    DremioModelProvider: () => DremioModelProvider,
+    EngineRejectRule: () => EngineRejectRule,
+    EngineRouteRule: () => EngineRouteRule,
+    FileUpload: () => FileUpload,
+    FolderSearchResult: () => FolderSearchResult,
+    FunctionSearchResult: () => FunctionSearchResult,
+    Grant: () => Grant,
+    HttpError: () => HttpError,
+    JobSearchResult: () => JobSearchResult,
+    ModelProvider: () => ModelProvider,
+    Organization: () => Organization,
+    Problem: () => Problem,
+    Query: () => Query,
+    ReflectionSearchResult: () => ReflectionSearchResult,
+    ScriptSearchResult: () => ScriptSearchResult,
+    SourceSearchResult: () => SourceSearchResult,
+    SpaceSearchResult: () => SpaceSearchResult,
+    TableSearchResult: () => TableSearchResult,
+    User: () => User2,
+    UserChatMessage: () => UserChatMessage,
+    ValidationProblem: () => ValidationProblem,
+    ViewSearchResult: () => ViewSearchResult,
+    _replaceOriginResource: () => _replaceOriginResource,
+    createAuthorizationCodeUrl: () => createAuthorizationCodeUrl,
+    createConversationPromptSchema: () => createConversationPromptSchema,
+    fromAccessToken: () => fromAccessToken,
+    fromPat: () => fromPat,
+    fromRefreshToken: () => fromRefreshToken,
+    fromTextEventStream: () => fromTextEventStream,
+    fromUsernamePassword: () => fromUsernamePassword,
+    isToolRequest: () => isToolRequest,
+    isToolResult: () => isToolResult
+  });
+
+  // dist/cloud/Dremio.js
+  var import_moize2 = __toESM(require_moize(), 1);
+
+  // node_modules/.pnpm/ts-results-es@6.0.0/node_modules/ts-results-es/dist/esm/utils.js
+  function toString(val) {
+    var value = String(val);
+    if (value === "[object Object]") {
+      try {
+        value = JSON.stringify(val);
+      } catch (_a) {
+      }
+    }
+    return value;
+  }
+
+  // node_modules/.pnpm/ts-results-es@6.0.0/node_modules/ts-results-es/dist/esm/option.js
+  var NoneImpl = (
+    /** @class */
+    (function() {
+      function NoneImpl2() {
+      }
+      NoneImpl2.prototype.isSome = function() {
+        return false;
       };
-      OkImpl2.prototype.unwrap = function() {
-        return this.value;
+      NoneImpl2.prototype.isNone = function() {
+        return true;
       };
-      OkImpl2.prototype.unwrapErr = function() {
-        throw new Error("Tried to unwrap Ok: ".concat(toString(this.value)), { cause: this.value });
+      NoneImpl2.prototype[Symbol.iterator] = function() {
+        return {
+          next: function() {
+            return { done: true, value: void 0 };
+          }
+        };
       };
-      OkImpl2.prototype.map = function(mapper) {
-        return new Ok(mapper(this.value));
+      NoneImpl2.prototype.unwrapOr = function(val) {
+        return val;
       };
-      OkImpl2.prototype.andThen = function(mapper) {
-        return mapper(this.value);
+      NoneImpl2.prototype.unwrapOrElse = function(f2) {
+        return f2();
       };
-      OkImpl2.prototype.mapErr = function(_mapper) {
+      NoneImpl2.prototype.expect = function(msg) {
+        throw new Error("".concat(msg));
+      };
+      NoneImpl2.prototype.unwrap = function() {
+        throw new Error("Tried to unwrap None");
+      };
+      NoneImpl2.prototype.map = function(_mapper) {
         return this;
       };
-      OkImpl2.prototype.mapOr = function(_default_, mapper) {
+      NoneImpl2.prototype.mapOr = function(default_, _mapper) {
+        return default_;
+      };
+      NoneImpl2.prototype.mapOrElse = function(default_, _mapper) {
+        return default_();
+      };
+      NoneImpl2.prototype.or = function(other) {
+        return other;
+      };
+      NoneImpl2.prototype.orElse = function(other) {
+        return other();
+      };
+      NoneImpl2.prototype.andThen = function(op) {
+        return this;
+      };
+      NoneImpl2.prototype.toResult = function(error) {
+        return Err(error);
+      };
+      NoneImpl2.prototype.toString = function() {
+        return "None";
+      };
+      NoneImpl2.prototype.toAsyncOption = function() {
+        return new AsyncOption(None);
+      };
+      return NoneImpl2;
+    })()
+  );
+  var None = new NoneImpl();
+  Object.freeze(None);
+  var SomeImpl = (
+    /** @class */
+    (function() {
+      function SomeImpl2(val) {
+        if (!(this instanceof SomeImpl2)) {
+          return new SomeImpl2(val);
+        }
+        this.value = val;
+      }
+      SomeImpl2.prototype.isSome = function() {
+        return true;
+      };
+      SomeImpl2.prototype.isNone = function() {
+        return false;
+      };
+      SomeImpl2.prototype[Symbol.iterator] = function() {
+        return [this.value][Symbol.iterator]();
+      };
+      SomeImpl2.prototype.unwrapOr = function(_val) {
+        return this.value;
+      };
+      SomeImpl2.prototype.unwrapOrElse = function(_f) {
+        return this.value;
+      };
+      SomeImpl2.prototype.expect = function(_msg) {
+        return this.value;
+      };
+      SomeImpl2.prototype.unwrap = function() {
+        return this.value;
+      };
+      SomeImpl2.prototype.map = function(mapper) {
+        return Some(mapper(this.value));
+      };
+      SomeImpl2.prototype.mapOr = function(_default_, mapper) {
         return mapper(this.value);
       };
-      OkImpl2.prototype.mapOrElse = function(_default_, mapper) {
+      SomeImpl2.prototype.mapOrElse = function(_default_, mapper) {
         return mapper(this.value);
       };
-      OkImpl2.prototype.or = function(_other) {
+      SomeImpl2.prototype.or = function(_other) {
         return this;
       };
-      OkImpl2.prototype.orElse = function(_other) {
+      SomeImpl2.prototype.orElse = function(_other) {
         return this;
       };
-      OkImpl2.prototype.toOption = function() {
-        return Some(this.value);
+      SomeImpl2.prototype.andThen = function(mapper) {
+        return mapper(this.value);
       };
-      OkImpl2.prototype.safeUnwrap = function() {
-        return this.value;
+      SomeImpl2.prototype.toResult = function(error) {
+        return Ok(this.value);
       };
-      OkImpl2.prototype.toString = function() {
-        return "Ok(".concat(toString(this.value), ")");
+      SomeImpl2.prototype.toAsyncOption = function() {
+        return new AsyncOption(this);
       };
-      OkImpl2.prototype.toAsyncResult = function() {
-        return new AsyncResult(this);
+      SomeImpl2.prototype.safeUnwrap = function() {
+        return this.value;
       };
-      OkImpl2.EMPTY = new OkImpl2(void 0);
-      return OkImpl2;
+      SomeImpl2.prototype.toString = function() {
+        return "Some(".concat(toString(this.value), ")");
+      };
+      SomeImpl2.EMPTY = new SomeImpl2(void 0);
+      return SomeImpl2;
     })()
   );
-  var Ok = OkImpl;
-  var Result;
-  (function(Result2) {
-    function all(results) {
-      var okResult = [];
-      for (var _i2 = 0, results_1 = results; _i2 < results_1.length; _i2++) {
-        var result = results_1[_i2];
-        if (result.isOk()) {
-          okResult.push(result.value);
+  var Some = SomeImpl;
+  var Option;
+  (function(Option2) {
+    function all() {
+      var options = [];
+      for (var _i2 = 0; _i2 < arguments.length; _i2++) {
+        options[_i2] = arguments[_i2];
+      }
+      var someOption = [];
+      for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {
+        var option = options_1[_a];
+        if (option.isSome()) {
+          someOption.push(option.value);
         } else {
-          return result;
+          return option;
         }
       }
-      return new Ok(okResult);
+      return Some(someOption);
     }
-    Result2.all = all;
-    function any(results) {
-      var errResult = [];
-      for (var _i2 = 0, results_2 = results; _i2 < results_2.length; _i2++) {
-        var result = results_2[_i2];
-        if (result.isOk()) {
-          return result;
+    Option2.all = all;
+    function any() {
+      var options = [];
+      for (var _i2 = 0; _i2 < arguments.length; _i2++) {
+        options[_i2] = arguments[_i2];
+      }
+      for (var _a = 0, options_2 = options; _a < options_2.length; _a++) {
+        var option = options_2[_a];
+        if (option.isSome()) {
+          return option;
         } else {
-          errResult.push(result.error);
+          continue;
         }
       }
-      return new Err(errResult);
+      return None;
     }
-    Result2.any = any;
-    function wrap(op) {
-      try {
-        return new Ok(op());
-      } catch (e2) {
-        return new Err(e2);
-      }
+    Option2.any = any;
+    function isOption(value) {
+      return value instanceof Some || value === None;
     }
-    Result2.wrap = wrap;
+    Option2.isOption = isOption;
+  })(Option || (Option = {}));
+
+  // node_modules/.pnpm/ts-results-es@6.0.0/node_modules/ts-results-es/dist/esm/result.js
+  var __spreadArray = function(to2, from2, pack) {
+    if (pack || arguments.length === 2) for (var i2 = 0, l2 = from2.length, ar2; i2 < l2; i2++) {
+      if (ar2 || !(i2 in from2)) {
+        if (!ar2) ar2 = Array.prototype.slice.call(from2, 0, i2);
+        ar2[i2] = from2[i2];
+      }
+    }
+    return to2.concat(ar2 || Array.prototype.slice.call(from2));
+  };
+  var ErrImpl = (
+    /** @class */
+    (function() {
+      function ErrImpl2(val) {
+        if (!(this instanceof ErrImpl2)) {
+          return new ErrImpl2(val);
+        }
+        this.error = val;
+        var stackLines = new Error().stack.split("\n").slice(2);
+        if (stackLines && stackLines.length > 0 && stackLines[0].includes("ErrImpl")) {
+          stackLines.shift();
+        }
+        this._stack = stackLines.join("\n");
+      }
+      ErrImpl2.prototype.isOk = function() {
+        return false;
+      };
+      ErrImpl2.prototype.isErr = function() {
+        return true;
+      };
+      ErrImpl2.prototype[Symbol.iterator] = function() {
+        return {
+          next: function() {
+            return { done: true, value: void 0 };
+          }
+        };
+      };
+      ErrImpl2.prototype.else = function(val) {
+        return val;
+      };
+      ErrImpl2.prototype.unwrapOr = function(val) {
+        return val;
+      };
+      ErrImpl2.prototype.unwrapOrElse = function(f2) {
+        return f2(this.error);
+      };
+      ErrImpl2.prototype.expect = function(msg) {
+        throw new Error("".concat(msg, " - Error: ").concat(toString(this.error), "\n").concat(this._stack), { cause: this.error });
+      };
+      ErrImpl2.prototype.expectErr = function(_msg) {
+        return this.error;
+      };
+      ErrImpl2.prototype.unwrap = function() {
+        throw new Error("Tried to unwrap Error: ".concat(toString(this.error), "\n").concat(this._stack), { cause: this.error });
+      };
+      ErrImpl2.prototype.unwrapErr = function() {
+        return this.error;
+      };
+      ErrImpl2.prototype.map = function(_mapper) {
+        return this;
+      };
+      ErrImpl2.prototype.andThen = function(op) {
+        return this;
+      };
+      ErrImpl2.prototype.mapErr = function(mapper) {
+        return new Err(mapper(this.error));
+      };
+      ErrImpl2.prototype.mapOr = function(default_, _mapper) {
+        return default_;
+      };
+      ErrImpl2.prototype.mapOrElse = function(default_, _mapper) {
+        return default_(this.error);
+      };
+      ErrImpl2.prototype.or = function(other) {
+        return other;
+      };
+      ErrImpl2.prototype.orElse = function(other) {
+        return other(this.error);
+      };
+      ErrImpl2.prototype.toOption = function() {
+        return None;
+      };
+      ErrImpl2.prototype.toString = function() {
+        return "Err(".concat(toString(this.error), ")");
+      };
+      Object.defineProperty(ErrImpl2.prototype, "stack", {
+        get: function() {
+          return "".concat(this, "\n").concat(this._stack);
+        },
+        enumerable: false,
+        configurable: true
+      });
+      ErrImpl2.prototype.toAsyncResult = function() {
+        return new AsyncResult(this);
+      };
+      ErrImpl2.EMPTY = new ErrImpl2(void 0);
+      return ErrImpl2;
+    })()
+  );
+  var Err = ErrImpl;
+  var OkImpl = (
+    /** @class */
+    (function() {
+      function OkImpl2(val) {
+        if (!(this instanceof OkImpl2)) {
+          return new OkImpl2(val);
+        }
+        this.value = val;
+      }
+      OkImpl2.prototype.isOk = function() {
+        return true;
+      };
+      OkImpl2.prototype.isErr = function() {
+        return false;
+      };
+      OkImpl2.prototype[Symbol.iterator] = function() {
+        return [this.value][Symbol.iterator]();
+      };
+      OkImpl2.prototype.else = function(_val) {
+        return this.value;
+      };
+      OkImpl2.prototype.unwrapOr = function(_val) {
+        return this.value;
+      };
+      OkImpl2.prototype.unwrapOrElse = function(_f) {
+        return this.value;
+      };
+      OkImpl2.prototype.expect = function(_msg) {
+        return this.value;
+      };
+      OkImpl2.prototype.expectErr = function(msg) {
+        throw new Error(msg);
+      };
+      OkImpl2.prototype.unwrap = function() {
+        return this.value;
+      };
+      OkImpl2.prototype.unwrapErr = function() {
+        throw new Error("Tried to unwrap Ok: ".concat(toString(this.value)), { cause: this.value });
+      };
+      OkImpl2.prototype.map = function(mapper) {
+        return new Ok(mapper(this.value));
+      };
+      OkImpl2.prototype.andThen = function(mapper) {
+        return mapper(this.value);
+      };
+      OkImpl2.prototype.mapErr = function(_mapper) {
+        return this;
+      };
+      OkImpl2.prototype.mapOr = function(_default_, mapper) {
+        return mapper(this.value);
+      };
+      OkImpl2.prototype.mapOrElse = function(_default_, mapper) {
+        return mapper(this.value);
+      };
+      OkImpl2.prototype.or = function(_other) {
+        return this;
+      };
+      OkImpl2.prototype.orElse = function(_other) {
+        return this;
+      };
+      OkImpl2.prototype.toOption = function() {
+        return Some(this.value);
+      };
+      OkImpl2.prototype.safeUnwrap = function() {
+        return this.value;
+      };
+      OkImpl2.prototype.toString = function() {
+        return "Ok(".concat(toString(this.value), ")");
+      };
+      OkImpl2.prototype.toAsyncResult = function() {
+        return new AsyncResult(this);
+      };
+      OkImpl2.EMPTY = new OkImpl2(void 0);
+      return OkImpl2;
+    })()
+  );
+  var Ok = OkImpl;
+  var Result;
+  (function(Result2) {
+    function all(results) {
+      var okResult = [];
+      for (var _i2 = 0, results_1 = results; _i2 < results_1.length; _i2++) {
+        var result = results_1[_i2];
+        if (result.isOk()) {
+          okResult.push(result.value);
+        } else {
+          return result;
+        }
+      }
+      return new Ok(okResult);
+    }
+    Result2.all = all;
+    function any(results) {
+      var errResult = [];
+      for (var _i2 = 0, results_2 = results; _i2 < results_2.length; _i2++) {
+        var result = results_2[_i2];
+        if (result.isOk()) {
+          return result;
+        } else {
+          errResult.push(result.error);
+        }
+      }
+      return new Err(errResult);
+    }
+    Result2.any = any;
+    function wrap(op) {
+      try {
+        return new Ok(op());
+      } catch (e2) {
+        return new Err(e2);
+      }
+    }
+    Result2.wrap = wrap;
     function wrapAsync(op) {
       try {
         return op().then(function(val) {
@@ -6989,454 +8897,14 @@ var DremioCloud = (() => {
   var emptyPathError = new ValidationProblem([
     {
       detail: "`path` parameter is required and cannot be empty",
-      pointer: "#/path",
-      type: "https://api.dremio.dev/problems/validation/min-length"
-    }
-  ]);
-  var unableToRetrieveProblem = (internalErrorMessage) => new Problem({
-    detail: internalErrorMessage,
-    title: "We were unable to fetch details for this catalog object",
-    type: "https://api.dremio.dev/problems/catalog/failed-to-retrieve"
-  });
-
-  // dist/enterprise/catalog/catalogRetrieve.js
-  var baseRetrieve = (config3) => batch(async (ids) => {
-    const results = /* @__PURE__ */ new Map();
-    if (ids.size === 1) {
-      const id = Array.from(ids).at(0);
-      return config3.sonarV3Request(`catalog/${id}?maxChildren=0`).promise.then((result) => result.unwrap()).then((res) => res.json()).then((response) => {
-        results.set(id, Ok(catalogObjectFromEntity(config3, baseRetrieveByPath(config3))(response)));
-        return results;
-      }).catch((e2) => {
-        if (e2 instanceof HttpError && e2.body?.detail) {
-          results.set(id, Err(unableToRetrieveProblem(e2.body.detail)));
-        } else {
-          results.set(id, Err(unableToRetrieveProblem()));
-        }
-        return results;
-      });
-    }
-    const idsArray = Array.from(ids);
-    const chunks = [];
-    while (idsArray.length > 0) {
-      chunks.push(idsArray.splice(0, Math.min(50, idsArray.length)));
-    }
-    const catalogItems = await Promise.all(chunks.map((chunk) => config3.sonarV3Request(`catalog/by-ids?maxChildren=0`, {
-      body: JSON.stringify(chunk),
-      headers: { "Content-Type": "application/json" },
-      method: "POST"
-    }).promise.then((result) => result.unwrap()).then((res) => res.json()).then((response) => response.data))).then((chunks2) => chunks2.flat());
-    for (const catalogItem of catalogItems) {
-      results.set(catalogItem.id, Ok(catalogObjectFromEntity(config3, baseRetrieveByPath(config3))(catalogItem)));
-    }
-    for (const id of ids) {
-      if (!results.has(id)) {
-        results.set(id, Err(unableToRetrieveProblem()));
-      }
-    }
-    return results;
-  });
-  var baseRetrieveByPath = (config3) => batch(async (paths) => {
-    const results = /* @__PURE__ */ new Map();
-    const originalKeyRef = /* @__PURE__ */ new Map();
-    for (const key of paths) {
-      originalKeyRef.set(JSON.stringify(key), key);
-    }
-    if (paths.size === 1) {
-      const path = Array.from(paths).at(0);
-      return config3.sonarV3Request(`catalog/by-path/${path.map(encodeURIComponent).join("/")}?maxChildren=0`).promise.then((result) => result.unwrap()).then((res) => res.json()).then((response) => {
-        results.set(path, Ok(catalogObjectFromEntity(config3, baseRetrieveByPath(config3))(response)));
-        return results;
-      }).catch((e2) => {
-        if (e2 instanceof HttpError && e2.body?.detail) {
-          results.set(path, Err(unableToRetrieveProblem(e2.body.detail)));
-        } else {
-          results.set(path, Err(unableToRetrieveProblem()));
-        }
-        return results;
-      });
-    }
-    const pathsArray = Array.from(paths);
-    const chunks = [];
-    while (pathsArray.length > 0) {
-      chunks.push(pathsArray.splice(0, Math.min(50, pathsArray.length)));
-    }
-    const catalogItems = await Promise.all(chunks.map((chunk) => config3.sonarV3Request(`catalog/by-paths?maxChildren=0`, {
-      body: JSON.stringify(chunk),
-      headers: { "Content-Type": "application/json" },
-      method: "POST"
-    }).promise.then((result) => result.unwrap()).then((res) => res.json()).then((response) => response.data))).then((chunks2) => chunks2.flat());
-    for (const catalogItem of catalogItems) {
-      const resolved = catalogObjectFromEntity(config3, baseRetrieveByPath(config3))(catalogItem);
-      const originalKey = originalKeyRef.get(JSON.stringify(resolved.path));
-      if (originalKey) {
-        results.set(originalKey, Ok(resolved));
-      }
-    }
-    for (const path of paths) {
-      if (!results.has(path)) {
-        results.set(path, Err(unableToRetrieveProblem()));
-      }
-    }
-    return results;
-  });
-
-  // dist/enterprise/catalog/catalogSearch/CatalogSearchParams.js
-  var dateRangeOptions = {
-    ALL: "ALL",
-    LAST_3_DAYS: "Last3Days",
-    LAST_6_HOURS: "Last6Hours",
-    LAST_7_DAYS: "Last7Days",
-    LAST_24_HOURS: "Last24Hours",
-    LAST_30_DAYS: "Last30Days",
-    LAST_HOUR: "LastHour"
-  };
-  var ONE_HOUR = 60 * 60 * 1e3;
-  var ONE_DAY = ONE_HOUR * 24;
-  var getDateRangeTime = (value) => {
-    const now = Date.now();
-    switch (value) {
-      case dateRangeOptions.LAST_HOUR:
-        return new Date(now - ONE_HOUR);
-      case dateRangeOptions.LAST_6_HOURS:
-        return new Date(now - ONE_HOUR * 6);
-      case dateRangeOptions.LAST_24_HOURS:
-        return new Date(now - ONE_DAY);
-      case dateRangeOptions.LAST_3_DAYS:
-        return new Date(now - ONE_DAY * 3);
-      case dateRangeOptions.LAST_7_DAYS:
-        return new Date(now - ONE_DAY * 7);
-      case dateRangeOptions.LAST_30_DAYS:
-        return new Date(now - ONE_DAY * 30);
-      default:
-        return /* @__PURE__ */ new Date();
-    }
-  };
-
-  // dist/enterprise/catalog/catalogSearch/catalogSearchParamsToObject.js
-  var catalogSearchParamsToObject = (catalogSearchParams) => {
-    const filters = [];
-    if (catalogSearchParams.type) {
-      filters.push(generateTypeFilterString(catalogSearchParams.type));
-    }
-    if (catalogSearchParams.owner) {
-      filters.push(`owner == "${catalogSearchParams.owner}"`);
-    }
-    if (catalogSearchParams.in) {
-      filters.push(`path == "${catalogSearchParams.in}"`);
-    }
-    if (catalogSearchParams.startTime && catalogSearchParams.startTime !== dateRangeOptions.ALL) {
-      filters.push(`date >= "${getDateRangeTime(catalogSearchParams.startTime)?.toISOString()}"`);
-    }
-    if (catalogSearchParams.lastModified && catalogSearchParams.lastModified !== dateRangeOptions.ALL) {
-      filters.push(`lastModified >= "${getDateRangeTime(catalogSearchParams.lastModified)?.toISOString()}"`);
-    }
-    return {
-      query: catalogSearchParams.searchText,
-      ...filters.length && { filter: filters.join(" && ") }
-    };
-  };
-  var generateTypeFilterString = (typeFilter) => {
-    if (typeFilter.size === 0) {
-      return "";
-    }
-    return `category in [${Array.from(typeFilter).map((v2) => JSON.stringify(v2)).join(",")}]`;
-  };
-
-  // dist/common/Query.js
-  var Query = class {
-    sql;
-    context;
-    constructor(sql, context2 = []) {
-      this.sql = sql;
-      this.context = context2;
-    }
-    equals(other) {
-      return typeof other === typeof this && this.sql === other.sql && JSON.stringify(this.context) === JSON.stringify(other.context);
-    }
-  };
-
-  // dist/enterprise/catalog/catalogSearch/CatalogSearchResult.js
-  var FolderSearchResult = class {
-    catalogReference;
-    owner;
-    wiki;
-    constructor(properties) {
-      this.catalogReference = properties.catalogReference;
-      this.owner = properties.owner;
-      this.wiki = properties.wiki;
-    }
-  };
-  var ReflectionSearchResult = class {
-    catalogReference;
-    createdAt;
-    id;
-    lastModifiedAt;
-    name;
-    constructor(properties) {
-      this.catalogReference = properties.catalogReference;
-      this.createdAt = properties.createdAt;
-      this.id = properties.id;
-      this.lastModifiedAt = properties.lastModifiedAt;
-      this.name = properties.name;
-    }
-  };
-  var SourceSearchResult = class {
-    catalogReference;
-    createdAt;
-    owner;
-    constructor(properties) {
-      this.catalogReference = properties.catalogReference;
-      this.createdAt = properties.createdAt;
-      this.owner = properties.owner;
-    }
-  };
-  var SpaceSearchResult = class {
-    catalogReference;
-    createdAt;
-    lastModifiedAt;
-    owner;
-    wiki;
-    constructor(properties) {
-      this.catalogReference = properties.catalogReference;
-      this.createdAt = properties.createdAt;
-      this.lastModifiedAt = properties.lastModifiedAt;
-      this.owner = properties.owner;
-      this.wiki = properties.wiki;
-    }
-  };
-  var TableSearchResult = class {
-    columns;
-    catalogReference;
-    createdAt;
-    labels;
-    lastModifiedAt;
-    owner;
-    wiki;
-    constructor(properties) {
-      this.catalogReference = properties.catalogReference;
-      this.columns = properties.columns;
-      this.createdAt = properties.createdAt;
-      this.labels = properties.labels;
-      this.lastModifiedAt = properties.lastModifiedAt;
-      this.wiki = properties.wiki;
-    }
-  };
-  var ViewSearchResult = class {
-    columns;
-    catalogReference;
-    createdAt;
-    labels;
-    lastModifiedAt;
-    owner;
-    wiki;
-    constructor(properties) {
-      this.columns = properties.columns;
-      this.catalogReference = properties.catalogReference;
-      this.createdAt = properties.createdAt;
-      this.labels = properties.labels;
-      this.lastModifiedAt = properties.lastModifiedAt;
-      this.owner = properties.owner;
-      this.wiki = properties.wiki;
-    }
-  };
-  var FunctionSearchResult = class {
-    catalogReference;
-    createdAt;
-    lastModifiedAt;
-    owner;
-    functionSql;
-    constructor(properties) {
-      this.catalogReference = properties.catalogReference;
-      this.createdAt = properties.createdAt;
-      this.lastModifiedAt = properties.lastModifiedAt;
-      this.owner = properties.owner;
-      this.functionSql = properties.functionSql;
-    }
-  };
-  var ScriptSearchResult = class {
-    content;
-    createdAt;
-    id;
-    lastModifiedAt;
-    name;
-    owner;
-    constructor(properties) {
-      this.content = properties.content;
-      this.createdAt = properties.createdAt;
-      this.id = properties.id;
-      this.lastModifiedAt = properties.lastModifiedAt;
-      this.name = properties.name;
-      this.owner = properties.owner;
-    }
-  };
-  var JobSearchResult = class {
-    id;
-    queriedDatasets;
-    sql;
-    queryType;
-    user;
-    startTime;
-    finishTime;
-    state;
-    error;
-    constructor(properties) {
-      this.id = properties.id;
-      this.queriedDatasets = properties.queriedDatasets;
-      this.sql = properties.sql;
-      this.queryType = properties.queryType;
-      this.user = properties.user;
-      this.startTime = properties.startTime;
-      this.finishTime = properties.finishTime;
-      this.state = properties.state;
-      this.error = properties.error;
-    }
-  };
-
-  // dist/enterprise/catalog/catalogSearch/mapSearchResult.js
-  var mapSearchResult = (_catalogReferenceFromEntity) => (searchResult) => {
-    switch (searchResult.category) {
-      case "FOLDER":
-        return new FolderSearchResult({
-          catalogReference: _catalogReferenceFromEntity({
-            path: searchResult.catalogObject.path,
-            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
-          }),
-          owner: searchResult.catalogObject?.owner,
-          wiki: searchResult.catalogObject.wiki || null
-        });
-      case "SCRIPT":
-        return new ScriptSearchResult({
-          content: searchResult.scriptObject.content,
-          createdAt: new Date(searchResult.scriptObject.createdAt),
-          id: searchResult.scriptObject.id,
-          lastModifiedAt: new Date(searchResult.scriptObject.modifiedAt),
-          name: searchResult.scriptObject.name,
-          owner: searchResult.scriptObject.owner
-        });
-      case "REFLECTION":
-        return new ReflectionSearchResult({
-          catalogReference: _catalogReferenceFromEntity({
-            path: searchResult.reflectionObject.datasetPath,
-            type: transformSearchTypeToCatalog(searchResult.reflectionObject.datasetType.toUpperCase())
-          }),
-          createdAt: new Date(searchResult.reflectionObject.createdAt),
-          id: searchResult.reflectionObject.id,
-          lastModifiedAt: new Date(searchResult.reflectionObject.modifiedAt),
-          name: searchResult.reflectionObject.name
-        });
-      case "SOURCE":
-        return new SourceSearchResult({
-          catalogReference: _catalogReferenceFromEntity({
-            path: searchResult.catalogObject.path,
-            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
-          }),
-          createdAt: new Date(searchResult.catalogObject.createdAt),
-          owner: searchResult.catalogObject.owner
-        });
-      case "SPACE":
-        return new SpaceSearchResult({
-          catalogReference: _catalogReferenceFromEntity({
-            path: searchResult.catalogObject.path,
-            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
-          }),
-          createdAt: searchResult.catalogObject.createdAt ? new Date(searchResult.catalogObject.createdAt) : null,
-          lastModifiedAt: searchResult.catalogObject.modifiedAt ? new Date(searchResult.catalogObject.modifiedAt) : null,
-          owner: searchResult.catalogObject.owner,
-          wiki: searchResult.catalogObject.wiki || null
-        });
-      case "TABLE":
-        return new TableSearchResult({
-          catalogReference: _catalogReferenceFromEntity({
-            path: searchResult.catalogObject.path,
-            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
-          }),
-          columns: searchResult.catalogObject.columns,
-          createdAt: searchResult.catalogObject.createdAt ? new Date(searchResult.catalogObject.createdAt) : null,
-          labels: searchResult.catalogObject.labels,
-          lastModifiedAt: searchResult.catalogObject.modifiedAt ? new Date(searchResult.catalogObject.modifiedAt) : null,
-          owner: searchResult.catalogObject.owner,
-          wiki: searchResult.catalogObject.wiki || null
-        });
-      case "UDF":
-        return new FunctionSearchResult({
-          catalogReference: _catalogReferenceFromEntity({
-            path: searchResult.catalogObject.path,
-            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
-          }),
-          createdAt: new Date(searchResult.catalogObject.createdAt),
-          functionSql: searchResult.catalogObject.functionSql,
-          lastModifiedAt: new Date(searchResult.catalogObject.modifiedAt),
-          owner: searchResult.catalogObject.owner
-        });
-      case "VIEW":
-        return new ViewSearchResult({
-          catalogReference: _catalogReferenceFromEntity({
-            path: searchResult.catalogObject.path,
-            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
-          }),
-          columns: searchResult.catalogObject.columns,
-          createdAt: searchResult.catalogObject.createdAt ? new Date(searchResult.catalogObject.createdAt) : null,
-          labels: searchResult.catalogObject.labels,
-          lastModifiedAt: searchResult.catalogObject.modifiedAt ? new Date(searchResult.catalogObject.modifiedAt) : null,
-          owner: searchResult.catalogObject.owner,
-          wiki: searchResult.catalogObject.wiki || null
-        });
-      case "JOB":
-        return new JobSearchResult({
-          error: searchResult.jobObject.error,
-          finishTime: new Date(searchResult.jobObject.finishTime),
-          id: searchResult.jobObject.id,
-          queriedDatasets: searchResult.jobObject.queriedDatasets.map((dataset) => _catalogReferenceFromEntity({
-            path: dataset.datasetPath,
-            type: transformSearchTypeToCatalog(dataset.datasetType)
-          })),
-          queryType: searchResult.jobObject.jobType,
-          sql: new Query(searchResult.jobObject.sql),
-          startTime: new Date(searchResult.jobObject.startTime),
-          state: searchResult.jobObject.jobState,
-          user: searchResult.jobObject.user
-        });
-    }
-  };
-  var transformSearchTypeToCatalog = (type) => {
-    switch (type) {
-      case "TABLE":
-        return "DATASET_DIRECT";
-      case "VIEW":
-        return "DATASET_VIRTUAL";
-      case "FOLDER":
-        return "FOLDER";
-      case "FUNCTION":
-        return "FUNCTION";
-      case "SPACE":
-        return "SPACE";
-      case "SOURCE":
-        return "SOURCE";
-      default:
-        return "FILE";
-    }
-  };
-
-  // dist/enterprise/catalog/catalogSearch/createCatalogSearch.js
-  var createCatalogSearch = (config3, _catalogReferenceFromEntity) => (params, { pageParam, signal } = {}) => config3.sonarV3Request("search", {
-    body: JSON.stringify({
-      ...catalogSearchParamsToObject(params),
-      maxResults: 50,
-      pageToken: pageParam
-    }),
-    headers: {
-      Accept: "application/json",
-      "Content-Type": "application/json"
-    },
-    method: "POST",
-    signal
-  }).map((res) => res.json()).map((response) => {
-    return {
-      data: response.results.map(mapSearchResult(_catalogReferenceFromEntity)),
-      nextPageToken: response.nextPageToken,
-      sessionId: response.sessionId
-    };
+      pointer: "#/path",
+      type: "https://api.dremio.dev/problems/validation/min-length"
+    }
+  ]);
+  var unableToRetrieveProblem = (internalErrorMessage) => new Problem({
+    detail: internalErrorMessage,
+    title: "We were unable to fetch details for this catalog object",
+    type: "https://api.dremio.dev/problems/catalog/failed-to-retrieve"
   });
 
   // node_modules/.pnpm/zod@4.1.11/node_modules/zod/v4/core/core.js
@@ -9459,6 +10927,15 @@ var DremioCloud = (() => {
     });
     return schema;
   }
+  function _refine(Class2, fn2, _params) {
+    const schema = new Class2({
+      type: "custom",
+      check: "custom",
+      fn: fn2,
+      ...normalizeParams(_params)
+    });
+    return schema;
+  }
   function _superRefine(fn2) {
     const ch = _check((payload) => {
       payload.addIssue = (issue2) => {
@@ -9732,6 +11209,9 @@ var DremioCloud = (() => {
   function custom(fn2, _params) {
     return _custom(ZodMiniCustom, fn2 ?? (() => true), _params);
   }
+  function refine(fn2, _params = {}) {
+    return _refine(ZodMiniCustom, fn2, _params);
+  }
   function superRefine(fn2) {
     return _superRefine(fn2);
   }
@@ -9743,46 +11223,557 @@ var DremioCloud = (() => {
     return inst;
   }
 
-  // node_modules/.pnpm/zod@4.1.11/node_modules/zod/v4/mini/iso.js
-  var iso_exports = {};
-  __export(iso_exports, {
-    ZodMiniISODate: () => ZodMiniISODate,
-    ZodMiniISODateTime: () => ZodMiniISODateTime,
-    ZodMiniISODuration: () => ZodMiniISODuration,
-    ZodMiniISOTime: () => ZodMiniISOTime,
-    date: () => date2,
-    datetime: () => datetime2,
-    duration: () => duration2,
-    time: () => time2
-  });
-  var ZodMiniISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
-    $ZodISODateTime.init(inst, def);
-    ZodMiniStringFormat.init(inst, def);
-  });
-  function datetime2(params) {
-    return _isoDateTime(ZodMiniISODateTime, params);
-  }
-  var ZodMiniISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
-    $ZodISODate.init(inst, def);
-    ZodMiniStringFormat.init(inst, def);
-  });
-  function date2(params) {
-    return _isoDate(ZodMiniISODate, params);
-  }
-  var ZodMiniISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
-    $ZodISOTime.init(inst, def);
-    ZodMiniStringFormat.init(inst, def);
-  });
-  function time2(params) {
-    return _isoTime(ZodMiniISOTime, params);
-  }
-  var ZodMiniISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
-    $ZodISODuration.init(inst, def);
-    ZodMiniStringFormat.init(inst, def);
+  // node_modules/.pnpm/zod@4.1.11/node_modules/zod/v4/mini/iso.js
+  var iso_exports = {};
+  __export(iso_exports, {
+    ZodMiniISODate: () => ZodMiniISODate,
+    ZodMiniISODateTime: () => ZodMiniISODateTime,
+    ZodMiniISODuration: () => ZodMiniISODuration,
+    ZodMiniISOTime: () => ZodMiniISOTime,
+    date: () => date2,
+    datetime: () => datetime2,
+    duration: () => duration2,
+    time: () => time2
+  });
+  var ZodMiniISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
+    $ZodISODateTime.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+  });
+  function datetime2(params) {
+    return _isoDateTime(ZodMiniISODateTime, params);
+  }
+  var ZodMiniISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
+    $ZodISODate.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+  });
+  function date2(params) {
+    return _isoDate(ZodMiniISODate, params);
+  }
+  var ZodMiniISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
+    $ZodISOTime.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+  });
+  function time2(params) {
+    return _isoTime(ZodMiniISOTime, params);
+  }
+  var ZodMiniISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
+    $ZodISODuration.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+  });
+  function duration2(params) {
+    return _isoDuration(ZodMiniISODuration, params);
+  }
+
+  // dist/oss/retrieveEnvironment.js
+  var import_semver = __toESM(require_semver2(), 1);
+  function retrieveEnvironment(config3) {
+    return config3.v3Request("info", {
+      headers: {
+        Accept: "application/json"
+      }
+    }).map((res) => res.json()).map((data) => decode(environmentCodec, data));
+  }
+  var environmentInSchema = object({
+    buildTime: string2().check(iso_exports.datetime()),
+    clusterType: string2(),
+    commit: object({
+      builder: string2(),
+      hash: string2(),
+      time: string2().check(iso_exports.datetime())
+    }),
+    version: string2().check(refine((val) => Boolean(import_semver.default.valid(val))))
+  });
+  var environmentCodec = codec(environmentInSchema, extend2(omit2(environmentInSchema, {
+    buildTime: true,
+    commit: true,
+    version: true
+  }), {
+    buildTime: _instanceof(Xn.Instant),
+    commit: extend2(omit2(environmentInSchema.shape.commit, {
+      time: true
+    }), {
+      time: _instanceof(Xn.Instant)
+    }),
+    version: _instanceof(import_semver.default.SemVer)
+  }), {
+    decode(v2) {
+      return {
+        buildTime: Xn.Instant.from(v2.buildTime),
+        clusterType: v2.clusterType,
+        commit: {
+          ...v2.commit,
+          time: Xn.Instant.from(v2.commit.time)
+        },
+        version: import_semver.default.parse(v2.version)
+      };
+    },
+    encode(v2) {
+      return {
+        buildTime: v2.buildTime.toString(),
+        clusterType: v2.clusterType,
+        commit: {
+          ...v2.commit,
+          time: v2.commit.time.toString()
+        },
+        version: v2.version.toString()
+      };
+    }
+  });
+
+  // dist/enterprise/catalog/catalogRetrieve.js
+  var versionPromiseCache = /* @__PURE__ */ new WeakMap();
+  var getVersionPromise = (config3) => {
+    if (!versionPromiseCache.has(config3)) {
+      versionPromiseCache.set(config3, retrieveEnvironment(config3).promise.then((result) => result.unwrap()).then((env) => env.version).catch(() => ({ major: 26 })));
+    }
+    return versionPromiseCache.get(config3);
+  };
+  var baseRetrieve = (config3) => {
+    const versionPromise = getVersionPromise(config3);
+    return batch(async (ids) => {
+      const results = /* @__PURE__ */ new Map();
+      const maxChildren = (await versionPromise).major < 26 ? 1 : 0;
+      if (ids.size === 1) {
+        const id = Array.from(ids).at(0);
+        return config3.sonarV3Request(`catalog/${id}?maxChildren=${maxChildren}`).promise.then((result) => result.unwrap()).then((res) => res.json()).then((response) => {
+          results.set(id, Ok(catalogObjectFromEntity(config3, baseRetrieveByPath(config3))(response)));
+          return results;
+        }).catch((e2) => {
+          if (e2 instanceof HttpError && e2.body?.detail) {
+            results.set(id, Err(unableToRetrieveProblem(e2.body.detail)));
+          } else {
+            results.set(id, Err(unableToRetrieveProblem()));
+          }
+          return results;
+        });
+      }
+      const idsArray = Array.from(ids);
+      const chunks = [];
+      while (idsArray.length > 0) {
+        chunks.push(idsArray.splice(0, Math.min(50, idsArray.length)));
+      }
+      const catalogItems = await Promise.all(chunks.map((chunk) => config3.sonarV3Request(`catalog/by-ids?maxChildren=${maxChildren}`, {
+        body: JSON.stringify(chunk),
+        headers: { "Content-Type": "application/json" },
+        method: "POST"
+      }).promise.then((result) => result.unwrap()).then((res) => res.json()).then((response) => response.data))).then((chunks2) => chunks2.flat());
+      for (const catalogItem of catalogItems) {
+        results.set(catalogItem.id, Ok(catalogObjectFromEntity(config3, baseRetrieveByPath(config3))(catalogItem)));
+      }
+      for (const id of ids) {
+        if (!results.has(id)) {
+          results.set(id, Err(unableToRetrieveProblem()));
+        }
+      }
+      return results;
+    });
+  };
+  var baseRetrieveByPath = (config3) => {
+    const versionPromise = getVersionPromise(config3);
+    return batch(async (paths) => {
+      const results = /* @__PURE__ */ new Map();
+      const maxChildren = (await versionPromise).major < 26 ? 1 : 0;
+      const originalKeyRef = /* @__PURE__ */ new Map();
+      for (const key of paths) {
+        originalKeyRef.set(JSON.stringify(key), key);
+      }
+      if (paths.size === 1) {
+        const path = Array.from(paths).at(0);
+        return config3.sonarV3Request(`catalog/by-path/${path.map(encodeURIComponent).join("/")}?maxChildren=${maxChildren}`).promise.then((result) => result.unwrap()).then((res) => res.json()).then((response) => {
+          results.set(path, Ok(catalogObjectFromEntity(config3, baseRetrieveByPath(config3))(response)));
+          return results;
+        }).catch((e2) => {
+          if (e2 instanceof HttpError && e2.body?.detail) {
+            results.set(path, Err(unableToRetrieveProblem(e2.body.detail)));
+          } else {
+            results.set(path, Err(unableToRetrieveProblem()));
+          }
+          return results;
+        });
+      }
+      const pathsArray = Array.from(paths);
+      const chunks = [];
+      while (pathsArray.length > 0) {
+        chunks.push(pathsArray.splice(0, Math.min(50, pathsArray.length)));
+      }
+      const catalogItems = await Promise.all(chunks.map((chunk) => config3.sonarV3Request(`catalog/by-paths?maxChildren=${maxChildren}`, {
+        body: JSON.stringify(chunk),
+        headers: { "Content-Type": "application/json" },
+        method: "POST"
+      }).promise.then((result) => result.unwrap()).then((res) => res.json()).then((response) => response.data))).then((chunks2) => chunks2.flat());
+      for (const catalogItem of catalogItems) {
+        const resolved = catalogObjectFromEntity(config3, baseRetrieveByPath(config3))(catalogItem);
+        const originalKey = originalKeyRef.get(JSON.stringify(resolved.path));
+        if (originalKey) {
+          results.set(originalKey, Ok(resolved));
+        }
+      }
+      for (const path of paths) {
+        if (!results.has(path)) {
+          results.set(path, Err(unableToRetrieveProblem()));
+        }
+      }
+      return results;
+    });
+  };
+
+  // dist/enterprise/catalog/catalogSearch/CatalogSearchParams.js
+  var dateRangeOptions = {
+    ALL: "ALL",
+    LAST_3_DAYS: "Last3Days",
+    LAST_6_HOURS: "Last6Hours",
+    LAST_7_DAYS: "Last7Days",
+    LAST_24_HOURS: "Last24Hours",
+    LAST_30_DAYS: "Last30Days",
+    LAST_HOUR: "LastHour"
+  };
+  var ONE_HOUR = 60 * 60 * 1e3;
+  var ONE_DAY = ONE_HOUR * 24;
+  var getDateRangeTime = (value) => {
+    const now = Date.now();
+    switch (value) {
+      case dateRangeOptions.LAST_HOUR:
+        return new Date(now - ONE_HOUR);
+      case dateRangeOptions.LAST_6_HOURS:
+        return new Date(now - ONE_HOUR * 6);
+      case dateRangeOptions.LAST_24_HOURS:
+        return new Date(now - ONE_DAY);
+      case dateRangeOptions.LAST_3_DAYS:
+        return new Date(now - ONE_DAY * 3);
+      case dateRangeOptions.LAST_7_DAYS:
+        return new Date(now - ONE_DAY * 7);
+      case dateRangeOptions.LAST_30_DAYS:
+        return new Date(now - ONE_DAY * 30);
+      default:
+        return /* @__PURE__ */ new Date();
+    }
+  };
+
+  // dist/enterprise/catalog/catalogSearch/catalogSearchParamsToObject.js
+  var catalogSearchParamsToObject = (catalogSearchParams) => {
+    const filters = [];
+    if (catalogSearchParams.type) {
+      filters.push(generateTypeFilterString(catalogSearchParams.type));
+    }
+    if (catalogSearchParams.owner) {
+      filters.push(`owner == "${catalogSearchParams.owner}"`);
+    }
+    if (catalogSearchParams.in) {
+      filters.push(`path == "${catalogSearchParams.in}"`);
+    }
+    if (catalogSearchParams.startTime && catalogSearchParams.startTime !== dateRangeOptions.ALL) {
+      filters.push(`date >= "${getDateRangeTime(catalogSearchParams.startTime)?.toISOString()}"`);
+    }
+    if (catalogSearchParams.lastModified && catalogSearchParams.lastModified !== dateRangeOptions.ALL) {
+      filters.push(`lastModified >= "${getDateRangeTime(catalogSearchParams.lastModified)?.toISOString()}"`);
+    }
+    return {
+      query: catalogSearchParams.searchText,
+      ...filters.length && { filter: filters.join(" && ") }
+    };
+  };
+  var generateTypeFilterString = (typeFilter) => {
+    if (typeFilter.size === 0) {
+      return "";
+    }
+    return `category in [${Array.from(typeFilter).map((v2) => JSON.stringify(v2)).join(",")}]`;
+  };
+
+  // dist/common/Query.js
+  var Query = class {
+    sql;
+    context;
+    constructor(sql, context2 = []) {
+      this.sql = sql;
+      this.context = context2;
+    }
+    equals(other) {
+      return typeof other === typeof this && this.sql === other.sql && JSON.stringify(this.context) === JSON.stringify(other.context);
+    }
+  };
+
+  // dist/enterprise/catalog/catalogSearch/CatalogSearchResult.js
+  var FolderSearchResult = class {
+    catalogReference;
+    owner;
+    wiki;
+    constructor(properties) {
+      this.catalogReference = properties.catalogReference;
+      this.owner = properties.owner;
+      this.wiki = properties.wiki;
+    }
+  };
+  var ReflectionSearchResult = class {
+    catalogReference;
+    createdAt;
+    id;
+    lastModifiedAt;
+    name;
+    constructor(properties) {
+      this.catalogReference = properties.catalogReference;
+      this.createdAt = properties.createdAt;
+      this.id = properties.id;
+      this.lastModifiedAt = properties.lastModifiedAt;
+      this.name = properties.name;
+    }
+  };
+  var SourceSearchResult = class {
+    catalogReference;
+    createdAt;
+    owner;
+    constructor(properties) {
+      this.catalogReference = properties.catalogReference;
+      this.createdAt = properties.createdAt;
+      this.owner = properties.owner;
+    }
+  };
+  var SpaceSearchResult = class {
+    catalogReference;
+    createdAt;
+    lastModifiedAt;
+    owner;
+    wiki;
+    constructor(properties) {
+      this.catalogReference = properties.catalogReference;
+      this.createdAt = properties.createdAt;
+      this.lastModifiedAt = properties.lastModifiedAt;
+      this.owner = properties.owner;
+      this.wiki = properties.wiki;
+    }
+  };
+  var TableSearchResult = class {
+    columns;
+    catalogReference;
+    createdAt;
+    labels;
+    lastModifiedAt;
+    owner;
+    wiki;
+    constructor(properties) {
+      this.catalogReference = properties.catalogReference;
+      this.columns = properties.columns;
+      this.createdAt = properties.createdAt;
+      this.labels = properties.labels;
+      this.lastModifiedAt = properties.lastModifiedAt;
+      this.wiki = properties.wiki;
+    }
+  };
+  var ViewSearchResult = class {
+    columns;
+    catalogReference;
+    createdAt;
+    labels;
+    lastModifiedAt;
+    owner;
+    wiki;
+    constructor(properties) {
+      this.columns = properties.columns;
+      this.catalogReference = properties.catalogReference;
+      this.createdAt = properties.createdAt;
+      this.labels = properties.labels;
+      this.lastModifiedAt = properties.lastModifiedAt;
+      this.owner = properties.owner;
+      this.wiki = properties.wiki;
+    }
+  };
+  var FunctionSearchResult = class {
+    catalogReference;
+    createdAt;
+    lastModifiedAt;
+    owner;
+    functionSql;
+    constructor(properties) {
+      this.catalogReference = properties.catalogReference;
+      this.createdAt = properties.createdAt;
+      this.lastModifiedAt = properties.lastModifiedAt;
+      this.owner = properties.owner;
+      this.functionSql = properties.functionSql;
+    }
+  };
+  var ScriptSearchResult = class {
+    content;
+    createdAt;
+    id;
+    lastModifiedAt;
+    name;
+    owner;
+    constructor(properties) {
+      this.content = properties.content;
+      this.createdAt = properties.createdAt;
+      this.id = properties.id;
+      this.lastModifiedAt = properties.lastModifiedAt;
+      this.name = properties.name;
+      this.owner = properties.owner;
+    }
+  };
+  var JobSearchResult = class {
+    id;
+    queriedDatasets;
+    sql;
+    queryType;
+    user;
+    startTime;
+    finishTime;
+    state;
+    error;
+    constructor(properties) {
+      this.id = properties.id;
+      this.queriedDatasets = properties.queriedDatasets;
+      this.sql = properties.sql;
+      this.queryType = properties.queryType;
+      this.user = properties.user;
+      this.startTime = properties.startTime;
+      this.finishTime = properties.finishTime;
+      this.state = properties.state;
+      this.error = properties.error;
+    }
+  };
+
+  // dist/enterprise/catalog/catalogSearch/mapSearchResult.js
+  var mapSearchResult = (_catalogReferenceFromEntity) => (searchResult) => {
+    switch (searchResult.category) {
+      case "FOLDER":
+        return new FolderSearchResult({
+          catalogReference: _catalogReferenceFromEntity({
+            path: searchResult.catalogObject.path,
+            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
+          }),
+          owner: searchResult.catalogObject?.owner,
+          wiki: searchResult.catalogObject.wiki || null
+        });
+      case "SCRIPT":
+        return new ScriptSearchResult({
+          content: searchResult.scriptObject.content,
+          createdAt: new Date(searchResult.scriptObject.createdAt),
+          id: searchResult.scriptObject.id,
+          lastModifiedAt: new Date(searchResult.scriptObject.modifiedAt),
+          name: searchResult.scriptObject.name,
+          owner: searchResult.scriptObject.owner
+        });
+      case "REFLECTION":
+        return new ReflectionSearchResult({
+          catalogReference: _catalogReferenceFromEntity({
+            path: searchResult.reflectionObject.datasetPath,
+            type: transformSearchTypeToCatalog(searchResult.reflectionObject.datasetType.toUpperCase())
+          }),
+          createdAt: new Date(searchResult.reflectionObject.createdAt),
+          id: searchResult.reflectionObject.id,
+          lastModifiedAt: new Date(searchResult.reflectionObject.modifiedAt),
+          name: searchResult.reflectionObject.name
+        });
+      case "SOURCE":
+        return new SourceSearchResult({
+          catalogReference: _catalogReferenceFromEntity({
+            path: searchResult.catalogObject.path,
+            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
+          }),
+          createdAt: new Date(searchResult.catalogObject.createdAt),
+          owner: searchResult.catalogObject.owner
+        });
+      case "SPACE":
+        return new SpaceSearchResult({
+          catalogReference: _catalogReferenceFromEntity({
+            path: searchResult.catalogObject.path,
+            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
+          }),
+          createdAt: searchResult.catalogObject.createdAt ? new Date(searchResult.catalogObject.createdAt) : null,
+          lastModifiedAt: searchResult.catalogObject.modifiedAt ? new Date(searchResult.catalogObject.modifiedAt) : null,
+          owner: searchResult.catalogObject.owner,
+          wiki: searchResult.catalogObject.wiki || null
+        });
+      case "TABLE":
+        return new TableSearchResult({
+          catalogReference: _catalogReferenceFromEntity({
+            path: searchResult.catalogObject.path,
+            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
+          }),
+          columns: searchResult.catalogObject.columns,
+          createdAt: searchResult.catalogObject.createdAt ? new Date(searchResult.catalogObject.createdAt) : null,
+          labels: searchResult.catalogObject.labels,
+          lastModifiedAt: searchResult.catalogObject.modifiedAt ? new Date(searchResult.catalogObject.modifiedAt) : null,
+          owner: searchResult.catalogObject.owner,
+          wiki: searchResult.catalogObject.wiki || null
+        });
+      case "UDF":
+        return new FunctionSearchResult({
+          catalogReference: _catalogReferenceFromEntity({
+            path: searchResult.catalogObject.path,
+            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
+          }),
+          createdAt: new Date(searchResult.catalogObject.createdAt),
+          functionSql: searchResult.catalogObject.functionSql,
+          lastModifiedAt: new Date(searchResult.catalogObject.modifiedAt),
+          owner: searchResult.catalogObject.owner
+        });
+      case "VIEW":
+        return new ViewSearchResult({
+          catalogReference: _catalogReferenceFromEntity({
+            path: searchResult.catalogObject.path,
+            type: transformSearchTypeToCatalog(searchResult.catalogObject.type)
+          }),
+          columns: searchResult.catalogObject.columns,
+          createdAt: searchResult.catalogObject.createdAt ? new Date(searchResult.catalogObject.createdAt) : null,
+          labels: searchResult.catalogObject.labels,
+          lastModifiedAt: searchResult.catalogObject.modifiedAt ? new Date(searchResult.catalogObject.modifiedAt) : null,
+          owner: searchResult.catalogObject.owner,
+          wiki: searchResult.catalogObject.wiki || null
+        });
+      case "JOB":
+        return new JobSearchResult({
+          error: searchResult.jobObject.error,
+          finishTime: new Date(searchResult.jobObject.finishTime),
+          id: searchResult.jobObject.id,
+          queriedDatasets: searchResult.jobObject.queriedDatasets.map((dataset) => _catalogReferenceFromEntity({
+            path: dataset.datasetPath,
+            type: transformSearchTypeToCatalog(dataset.datasetType)
+          })),
+          queryType: searchResult.jobObject.jobType,
+          sql: new Query(searchResult.jobObject.sql),
+          startTime: new Date(searchResult.jobObject.startTime),
+          state: searchResult.jobObject.jobState,
+          user: searchResult.jobObject.user
+        });
+    }
+  };
+  var transformSearchTypeToCatalog = (type) => {
+    switch (type) {
+      case "TABLE":
+        return "DATASET_DIRECT";
+      case "VIEW":
+        return "DATASET_VIRTUAL";
+      case "FOLDER":
+        return "FOLDER";
+      case "FUNCTION":
+        return "FUNCTION";
+      case "SPACE":
+        return "SPACE";
+      case "SOURCE":
+        return "SOURCE";
+      default:
+        return "FILE";
+    }
+  };
+
+  // dist/enterprise/catalog/catalogSearch/createCatalogSearch.js
+  var createCatalogSearch = (config3, _catalogReferenceFromEntity) => (params, { pageParam, signal } = {}) => config3.sonarV3Request("search", {
+    body: JSON.stringify({
+      ...catalogSearchParamsToObject(params),
+      maxResults: 50,
+      pageToken: pageParam
+    }),
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    method: "POST",
+    signal
+  }).map((res) => res.json()).map((response) => {
+    return {
+      data: response.results.map(mapSearchResult(_catalogReferenceFromEntity)),
+      nextPageToken: response.nextPageToken,
+      sessionId: response.sessionId
+    };
   });
-  function duration2(params) {
-    return _isoDuration(ZodMiniISODuration, params);
-  }
 
   // dist/cloud/catalog/FileUpload.js
   var uploadExtensionSchema = _enum(["csv", "json", "parquet"]);
@@ -12146,7 +14137,7 @@ var DremioCloud = (() => {
   }
   function fromAsyncIterable(asyncIterable) {
     return new Observable(function(subscriber) {
-      process(asyncIterable, subscriber).catch(function(err) {
+      process2(asyncIterable, subscriber).catch(function(err) {
         return subscriber.error(err);
       });
     });
@@ -12154,7 +14145,7 @@ var DremioCloud = (() => {
   function fromReadableStreamLike(readableStream) {
     return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
   }
-  function process(asyncIterable, subscriber) {
+  function process2(asyncIterable, subscriber) {
     var asyncIterable_1, asyncIterable_1_1;
     var e_2, _a;
     return __awaiter3(this, void 0, void 0, function() {
@@ -14258,6 +16249,17 @@ var DremioCloud = (() => {
         signal
       });
     }
+    patchParentRoles(userId, params, { signal } = {}) {
+      return this.#config.v3Request(`users/${userId}/parent-roles`, {
+        body: JSON.stringify(params),
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        method: "PATCH",
+        signal
+      }).map((res) => res.json());
+    }
     removeParentRole(userId, roleId, { signal } = {}) {
       return this.#config.v3Request(`users/${userId}/parent-roles/${roleId}`, {
         method: "DELETE",