@wix/create-headless-site 0.0.2

package/build/chunk-YU54OBFT.js

@@ -0,0 +1,3451 @@
+import { createRequire as _createRequire } from 'node:module';
+const require = _createRequire(import.meta.url);
+import {
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-PYIAC2GK.js";
+
+// ../../node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
+var _globalThis;
+var init_globalThis = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js"() {
+    "use strict";
+    init_esm_shims();
+    _globalThis = typeof globalThis === "object" ? globalThis : global;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/platform/node/index.js
+var init_node = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_globalThis();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/platform/index.js
+var init_platform = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_node();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION;
+var init_version = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/version.js"() {
+    "use strict";
+    init_esm_shims();
+    VERSION = "1.9.0";
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/internal/semver.js
+function _makeCompatibilityCheck(ownVersion) {
+  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  var rejectedVersions = /* @__PURE__ */ new Set();
+  var myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return function() {
+      return false;
+    };
+  }
+  var ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    };
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  return function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    var globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    var globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  };
+}
+var re, isCompatible;
+var init_semver = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
+    "use strict";
+    init_esm_shims();
+    init_version();
+    re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+    isCompatible = _makeCompatibilityCheck(VERSION);
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+function registerGlobal(type, instance, diag3, allowOverride) {
+  var _a;
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag3.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+    diag3.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag3.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag3) {
+  diag3.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
+var init_global_utils = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
+    "use strict";
+    init_esm_shims();
+    init_platform();
+    init_version();
+    init_semver();
+    major = VERSION.split(".")[0];
+    GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+    _global = _globalThis;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+function logProxy(funcName, namespace, args) {
+  var logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  args.unshift(namespace);
+  return logger[funcName].apply(logger, __spreadArray([], __read(args), false));
+}
+var __read, __spreadArray, DiagComponentLogger;
+var init_ComponentLogger = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
+    "use strict";
+    init_esm_shims();
+    init_global_utils();
+    __read = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    DiagComponentLogger = /** @class */
+    function() {
+      function DiagComponentLogger2(props) {
+        this._namespace = props.namespace || "DiagComponentLogger";
+      }
+      DiagComponentLogger2.prototype.debug = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("debug", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.error = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("error", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.info = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("info", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.warn = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("warn", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.verbose = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("verbose", this._namespace, args);
+      };
+      return DiagComponentLogger2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+var init_types = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
+    "use strict";
+    init_esm_shims();
+    (function(DiagLogLevel2) {
+      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+    })(DiagLogLevel || (DiagLogLevel = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    var theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+var init_logLevelLogger = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
+    "use strict";
+    init_esm_shims();
+    init_types();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/api/diag.js
+var __read2, __spreadArray2, API_NAME, DiagAPI;
+var init_diag = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
+    "use strict";
+    init_esm_shims();
+    init_ComponentLogger();
+    init_logLevelLogger();
+    init_types();
+    init_global_utils();
+    __read2 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray2 = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    API_NAME = "diag";
+    DiagAPI = /** @class */
+    function() {
+      function DiagAPI2() {
+        function _logProxy(funcName) {
+          return function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            var logger = getGlobal("diag");
+            if (!logger)
+              return;
+            return logger[funcName].apply(logger, __spreadArray2([], __read2(args), false));
+          };
+        }
+        var self = this;
+        var setLogger = function(logger, optionsOrLogLevel) {
+          var _a, _b, _c;
+          if (optionsOrLogLevel === void 0) {
+            optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+          }
+          if (logger === self) {
+            var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+            self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            return false;
+          }
+          if (typeof optionsOrLogLevel === "number") {
+            optionsOrLogLevel = {
+              logLevel: optionsOrLogLevel
+            };
+          }
+          var oldLogger = getGlobal("diag");
+          var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+            var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+            oldLogger.warn("Current logger will be overwritten from " + stack);
+            newLogger.warn("Current logger will overwrite one already registered from " + stack);
+          }
+          return registerGlobal("diag", newLogger, self, true);
+        };
+        self.setLogger = setLogger;
+        self.disable = function() {
+          unregisterGlobal(API_NAME, self);
+        };
+        self.createComponentLogger = function(options) {
+          return new DiagComponentLogger(options);
+        };
+        self.verbose = _logProxy("verbose");
+        self.debug = _logProxy("debug");
+        self.info = _logProxy("info");
+        self.warn = _logProxy("warn");
+        self.error = _logProxy("error");
+      }
+      DiagAPI2.instance = function() {
+        if (!this._instance) {
+          this._instance = new DiagAPI2();
+        }
+        return this._instance;
+      };
+      return DiagAPI2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js
+var __read3, __values, BaggageImpl;
+var init_baggage_impl = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js"() {
+    "use strict";
+    init_esm_shims();
+    __read3 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __values = function(o) {
+      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+      if (m) return m.call(o);
+      if (o && typeof o.length === "number") return {
+        next: function() {
+          if (o && i >= o.length) o = void 0;
+          return { value: o && o[i++], done: !o };
+        }
+      };
+      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    };
+    BaggageImpl = /** @class */
+    function() {
+      function BaggageImpl2(entries) {
+        this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+      }
+      BaggageImpl2.prototype.getEntry = function(key) {
+        var entry = this._entries.get(key);
+        if (!entry) {
+          return void 0;
+        }
+        return Object.assign({}, entry);
+      };
+      BaggageImpl2.prototype.getAllEntries = function() {
+        return Array.from(this._entries.entries()).map(function(_a) {
+          var _b = __read3(_a, 2), k = _b[0], v = _b[1];
+          return [k, v];
+        });
+      };
+      BaggageImpl2.prototype.setEntry = function(key, entry) {
+        var newBaggage = new BaggageImpl2(this._entries);
+        newBaggage._entries.set(key, entry);
+        return newBaggage;
+      };
+      BaggageImpl2.prototype.removeEntry = function(key) {
+        var newBaggage = new BaggageImpl2(this._entries);
+        newBaggage._entries.delete(key);
+        return newBaggage;
+      };
+      BaggageImpl2.prototype.removeEntries = function() {
+        var e_1, _a;
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          keys[_i] = arguments[_i];
+        }
+        var newBaggage = new BaggageImpl2(this._entries);
+        try {
+          for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            newBaggage._entries.delete(key);
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+        return newBaggage;
+      };
+      BaggageImpl2.prototype.clear = function() {
+        return new BaggageImpl2();
+      };
+      return BaggageImpl2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js
+var baggageEntryMetadataSymbol;
+var init_symbol = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js"() {
+    "use strict";
+    init_esm_shims();
+    baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/baggage/utils.js
+function createBaggage(entries) {
+  if (entries === void 0) {
+    entries = {};
+  }
+  return new BaggageImpl(new Map(Object.entries(entries)));
+}
+function baggageEntryMetadataFromString(str) {
+  if (typeof str !== "string") {
+    diag.error("Cannot create baggage metadata from unknown type: " + typeof str);
+    str = "";
+  }
+  return {
+    __TYPE__: baggageEntryMetadataSymbol,
+    toString: function() {
+      return str;
+    }
+  };
+}
+var diag;
+var init_utils = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/baggage/utils.js"() {
+    "use strict";
+    init_esm_shims();
+    init_diag();
+    init_baggage_impl();
+    init_symbol();
+    diag = DiagAPI.instance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/context/context.js
+function createContextKey(description) {
+  return Symbol.for(description);
+}
+var BaseContext, ROOT_CONTEXT;
+var init_context = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/context/context.js"() {
+    "use strict";
+    init_esm_shims();
+    BaseContext = /** @class */
+    /* @__PURE__ */ function() {
+      function BaseContext2(parentContext) {
+        var self = this;
+        self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+        self.getValue = function(key) {
+          return self._currentContext.get(key);
+        };
+        self.setValue = function(key, value) {
+          var context2 = new BaseContext2(self._currentContext);
+          context2._currentContext.set(key, value);
+          return context2;
+        };
+        self.deleteValue = function(key) {
+          var context2 = new BaseContext2(self._currentContext);
+          context2._currentContext.delete(key);
+          return context2;
+        };
+      }
+      return BaseContext2;
+    }();
+    ROOT_CONTEXT = new BaseContext();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js
+var consoleMap, DiagConsoleLogger;
+var init_consoleLogger = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js"() {
+    "use strict";
+    init_esm_shims();
+    consoleMap = [
+      { n: "error", c: "error" },
+      { n: "warn", c: "warn" },
+      { n: "info", c: "info" },
+      { n: "debug", c: "debug" },
+      { n: "verbose", c: "trace" }
+    ];
+    DiagConsoleLogger = /** @class */
+    /* @__PURE__ */ function() {
+      function DiagConsoleLogger2() {
+        function _consoleFunc(funcName) {
+          return function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            if (console) {
+              var theFunc = console[funcName];
+              if (typeof theFunc !== "function") {
+                theFunc = console.log;
+              }
+              if (typeof theFunc === "function") {
+                return theFunc.apply(console, args);
+              }
+            }
+          };
+        }
+        for (var i = 0; i < consoleMap.length; i++) {
+          this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+        }
+      }
+      return DiagConsoleLogger2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
+function createNoopMeter() {
+  return NOOP_METER;
+}
+var __extends, NoopMeter, NoopMetric, NoopCounterMetric, NoopUpDownCounterMetric, NoopGaugeMetric, NoopHistogramMetric, NoopObservableMetric, NoopObservableCounterMetric, NoopObservableGaugeMetric, NoopObservableUpDownCounterMetric, NOOP_METER, NOOP_COUNTER_METRIC, NOOP_GAUGE_METRIC, NOOP_HISTOGRAM_METRIC, NOOP_UP_DOWN_COUNTER_METRIC, NOOP_OBSERVABLE_COUNTER_METRIC, NOOP_OBSERVABLE_GAUGE_METRIC, NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+var init_NoopMeter = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js"() {
+    "use strict";
+    init_esm_shims();
+    __extends = /* @__PURE__ */ function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    NoopMeter = /** @class */
+    function() {
+      function NoopMeter2() {
+      }
+      NoopMeter2.prototype.createGauge = function(_name, _options) {
+        return NOOP_GAUGE_METRIC;
+      };
+      NoopMeter2.prototype.createHistogram = function(_name, _options) {
+        return NOOP_HISTOGRAM_METRIC;
+      };
+      NoopMeter2.prototype.createCounter = function(_name, _options) {
+        return NOOP_COUNTER_METRIC;
+      };
+      NoopMeter2.prototype.createUpDownCounter = function(_name, _options) {
+        return NOOP_UP_DOWN_COUNTER_METRIC;
+      };
+      NoopMeter2.prototype.createObservableGauge = function(_name, _options) {
+        return NOOP_OBSERVABLE_GAUGE_METRIC;
+      };
+      NoopMeter2.prototype.createObservableCounter = function(_name, _options) {
+        return NOOP_OBSERVABLE_COUNTER_METRIC;
+      };
+      NoopMeter2.prototype.createObservableUpDownCounter = function(_name, _options) {
+        return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+      };
+      NoopMeter2.prototype.addBatchObservableCallback = function(_callback, _observables) {
+      };
+      NoopMeter2.prototype.removeBatchObservableCallback = function(_callback) {
+      };
+      return NoopMeter2;
+    }();
+    NoopMetric = /** @class */
+    /* @__PURE__ */ function() {
+      function NoopMetric2() {
+      }
+      return NoopMetric2;
+    }();
+    NoopCounterMetric = /** @class */
+    function(_super) {
+      __extends(NoopCounterMetric2, _super);
+      function NoopCounterMetric2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      NoopCounterMetric2.prototype.add = function(_value, _attributes) {
+      };
+      return NoopCounterMetric2;
+    }(NoopMetric);
+    NoopUpDownCounterMetric = /** @class */
+    function(_super) {
+      __extends(NoopUpDownCounterMetric2, _super);
+      function NoopUpDownCounterMetric2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      NoopUpDownCounterMetric2.prototype.add = function(_value, _attributes) {
+      };
+      return NoopUpDownCounterMetric2;
+    }(NoopMetric);
+    NoopGaugeMetric = /** @class */
+    function(_super) {
+      __extends(NoopGaugeMetric2, _super);
+      function NoopGaugeMetric2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      NoopGaugeMetric2.prototype.record = function(_value, _attributes) {
+      };
+      return NoopGaugeMetric2;
+    }(NoopMetric);
+    NoopHistogramMetric = /** @class */
+    function(_super) {
+      __extends(NoopHistogramMetric2, _super);
+      function NoopHistogramMetric2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      NoopHistogramMetric2.prototype.record = function(_value, _attributes) {
+      };
+      return NoopHistogramMetric2;
+    }(NoopMetric);
+    NoopObservableMetric = /** @class */
+    function() {
+      function NoopObservableMetric2() {
+      }
+      NoopObservableMetric2.prototype.addCallback = function(_callback) {
+      };
+      NoopObservableMetric2.prototype.removeCallback = function(_callback) {
+      };
+      return NoopObservableMetric2;
+    }();
+    NoopObservableCounterMetric = /** @class */
+    function(_super) {
+      __extends(NoopObservableCounterMetric2, _super);
+      function NoopObservableCounterMetric2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      return NoopObservableCounterMetric2;
+    }(NoopObservableMetric);
+    NoopObservableGaugeMetric = /** @class */
+    function(_super) {
+      __extends(NoopObservableGaugeMetric2, _super);
+      function NoopObservableGaugeMetric2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      return NoopObservableGaugeMetric2;
+    }(NoopObservableMetric);
+    NoopObservableUpDownCounterMetric = /** @class */
+    function(_super) {
+      __extends(NoopObservableUpDownCounterMetric2, _super);
+      function NoopObservableUpDownCounterMetric2() {
+        return _super !== null && _super.apply(this, arguments) || this;
+      }
+      return NoopObservableUpDownCounterMetric2;
+    }(NoopObservableMetric);
+    NOOP_METER = new NoopMeter();
+    NOOP_COUNTER_METRIC = new NoopCounterMetric();
+    NOOP_GAUGE_METRIC = new NoopGaugeMetric();
+    NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
+    NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
+    NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
+    NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
+    NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/metrics/Metric.js
+var ValueType;
+var init_Metric = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/metrics/Metric.js"() {
+    "use strict";
+    init_esm_shims();
+    (function(ValueType2) {
+      ValueType2[ValueType2["INT"] = 0] = "INT";
+      ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
+    })(ValueType || (ValueType = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
+var defaultTextMapGetter, defaultTextMapSetter;
+var init_TextMapPropagator = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js"() {
+    "use strict";
+    init_esm_shims();
+    defaultTextMapGetter = {
+      get: function(carrier, key) {
+        if (carrier == null) {
+          return void 0;
+        }
+        return carrier[key];
+      },
+      keys: function(carrier) {
+        if (carrier == null) {
+          return [];
+        }
+        return Object.keys(carrier);
+      }
+    };
+    defaultTextMapSetter = {
+      set: function(carrier, key, value) {
+        if (carrier == null) {
+          return;
+        }
+        carrier[key] = value;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var __read4, __spreadArray3, NoopContextManager;
+var init_NoopContextManager = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js"() {
+    "use strict";
+    init_esm_shims();
+    init_context();
+    __read4 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray3 = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    NoopContextManager = /** @class */
+    function() {
+      function NoopContextManager2() {
+      }
+      NoopContextManager2.prototype.active = function() {
+        return ROOT_CONTEXT;
+      };
+      NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
+        var args = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+          args[_i - 3] = arguments[_i];
+        }
+        return fn.call.apply(fn, __spreadArray3([thisArg], __read4(args), false));
+      };
+      NoopContextManager2.prototype.bind = function(_context, target) {
+        return target;
+      };
+      NoopContextManager2.prototype.enable = function() {
+        return this;
+      };
+      NoopContextManager2.prototype.disable = function() {
+        return this;
+      };
+      return NoopContextManager2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/api/context.js
+var __read5, __spreadArray4, API_NAME2, NOOP_CONTEXT_MANAGER, ContextAPI;
+var init_context2 = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/api/context.js"() {
+    "use strict";
+    init_esm_shims();
+    init_NoopContextManager();
+    init_global_utils();
+    init_diag();
+    __read5 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray4 = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    API_NAME2 = "context";
+    NOOP_CONTEXT_MANAGER = new NoopContextManager();
+    ContextAPI = /** @class */
+    function() {
+      function ContextAPI2() {
+      }
+      ContextAPI2.getInstance = function() {
+        if (!this._instance) {
+          this._instance = new ContextAPI2();
+        }
+        return this._instance;
+      };
+      ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
+        return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+      };
+      ContextAPI2.prototype.active = function() {
+        return this._getContextManager().active();
+      };
+      ContextAPI2.prototype.with = function(context2, fn, thisArg) {
+        var _a;
+        var args = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+          args[_i - 3] = arguments[_i];
+        }
+        return (_a = this._getContextManager()).with.apply(_a, __spreadArray4([context2, fn, thisArg], __read5(args), false));
+      };
+      ContextAPI2.prototype.bind = function(context2, target) {
+        return this._getContextManager().bind(context2, target);
+      };
+      ContextAPI2.prototype._getContextManager = function() {
+        return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+      };
+      ContextAPI2.prototype.disable = function() {
+        this._getContextManager().disable();
+        unregisterGlobal(API_NAME2, DiagAPI.instance());
+      };
+      return ContextAPI2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+var TraceFlags;
+var init_trace_flags = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js"() {
+    "use strict";
+    init_esm_shims();
+    (function(TraceFlags2) {
+      TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+      TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+    })(TraceFlags || (TraceFlags = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
+var init_invalid_span_constants = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js"() {
+    "use strict";
+    init_esm_shims();
+    init_trace_flags();
+    INVALID_SPANID = "0000000000000000";
+    INVALID_TRACEID = "00000000000000000000000000000000";
+    INVALID_SPAN_CONTEXT = {
+      traceId: INVALID_TRACEID,
+      spanId: INVALID_SPANID,
+      traceFlags: TraceFlags.NONE
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+var NonRecordingSpan;
+var init_NonRecordingSpan = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js"() {
+    "use strict";
+    init_esm_shims();
+    init_invalid_span_constants();
+    NonRecordingSpan = /** @class */
+    function() {
+      function NonRecordingSpan2(_spanContext) {
+        if (_spanContext === void 0) {
+          _spanContext = INVALID_SPAN_CONTEXT;
+        }
+        this._spanContext = _spanContext;
+      }
+      NonRecordingSpan2.prototype.spanContext = function() {
+        return this._spanContext;
+      };
+      NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.addLink = function(_link) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.addLinks = function(_links) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.setStatus = function(_status) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.updateName = function(_name) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.end = function(_endTime) {
+      };
+      NonRecordingSpan2.prototype.isRecording = function() {
+        return false;
+      };
+      NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
+      };
+      return NonRecordingSpan2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
+function getSpan(context2) {
+  return context2.getValue(SPAN_KEY) || void 0;
+}
+function getActiveSpan() {
+  return getSpan(ContextAPI.getInstance().active());
+}
+function setSpan(context2, span) {
+  return context2.setValue(SPAN_KEY, span);
+}
+function deleteSpan(context2) {
+  return context2.deleteValue(SPAN_KEY);
+}
+function setSpanContext(context2, spanContext) {
+  return setSpan(context2, new NonRecordingSpan(spanContext));
+}
+function getSpanContext(context2) {
+  var _a;
+  return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
+}
+var SPAN_KEY;
+var init_context_utils = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js"() {
+    "use strict";
+    init_esm_shims();
+    init_context();
+    init_NonRecordingSpan();
+    init_context2();
+    SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+function isValidTraceId(traceId) {
+  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
+}
+function isValidSpanId(spanId) {
+  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
+}
+function isSpanContextValid(spanContext) {
+  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+function wrapSpanContext(spanContext) {
+  return new NonRecordingSpan(spanContext);
+}
+var VALID_TRACEID_REGEX, VALID_SPANID_REGEX;
+var init_spancontext_utils = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js"() {
+    "use strict";
+    init_esm_shims();
+    init_invalid_span_constants();
+    init_NonRecordingSpan();
+    VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+    VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+function isSpanContext(spanContext) {
+  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
+}
+var contextApi, NoopTracer;
+var init_NoopTracer = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js"() {
+    "use strict";
+    init_esm_shims();
+    init_context2();
+    init_context_utils();
+    init_NonRecordingSpan();
+    init_spancontext_utils();
+    contextApi = ContextAPI.getInstance();
+    NoopTracer = /** @class */
+    function() {
+      function NoopTracer2() {
+      }
+      NoopTracer2.prototype.startSpan = function(name, options, context2) {
+        if (context2 === void 0) {
+          context2 = contextApi.active();
+        }
+        var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+        if (root) {
+          return new NonRecordingSpan();
+        }
+        var parentFromContext = context2 && getSpanContext(context2);
+        if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+          return new NonRecordingSpan(parentFromContext);
+        } else {
+          return new NonRecordingSpan();
+        }
+      };
+      NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
+        var opts;
+        var ctx;
+        var fn;
+        if (arguments.length < 2) {
+          return;
+        } else if (arguments.length === 2) {
+          fn = arg2;
+        } else if (arguments.length === 3) {
+          opts = arg2;
+          fn = arg3;
+        } else {
+          opts = arg2;
+          ctx = arg3;
+          fn = arg4;
+        }
+        var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+        var span = this.startSpan(name, opts, parentContext);
+        var contextWithSpanSet = setSpan(parentContext, span);
+        return contextApi.with(contextWithSpanSet, fn, void 0, span);
+      };
+      return NoopTracer2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+var NOOP_TRACER, ProxyTracer;
+var init_ProxyTracer = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js"() {
+    "use strict";
+    init_esm_shims();
+    init_NoopTracer();
+    NOOP_TRACER = new NoopTracer();
+    ProxyTracer = /** @class */
+    function() {
+      function ProxyTracer2(_provider, name, version, options) {
+        this._provider = _provider;
+        this.name = name;
+        this.version = version;
+        this.options = options;
+      }
+      ProxyTracer2.prototype.startSpan = function(name, options, context2) {
+        return this._getTracer().startSpan(name, options, context2);
+      };
+      ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
+        var tracer = this._getTracer();
+        return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+      };
+      ProxyTracer2.prototype._getTracer = function() {
+        if (this._delegate) {
+          return this._delegate;
+        }
+        var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+        if (!tracer) {
+          return NOOP_TRACER;
+        }
+        this._delegate = tracer;
+        return this._delegate;
+      };
+      return ProxyTracer2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+var NoopTracerProvider;
+var init_NoopTracerProvider = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js"() {
+    "use strict";
+    init_esm_shims();
+    init_NoopTracer();
+    NoopTracerProvider = /** @class */
+    function() {
+      function NoopTracerProvider2() {
+      }
+      NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
+        return new NoopTracer();
+      };
+      return NoopTracerProvider2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+var NOOP_TRACER_PROVIDER, ProxyTracerProvider;
+var init_ProxyTracerProvider = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js"() {
+    "use strict";
+    init_esm_shims();
+    init_ProxyTracer();
+    init_NoopTracerProvider();
+    NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+    ProxyTracerProvider = /** @class */
+    function() {
+      function ProxyTracerProvider2() {
+      }
+      ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
+        var _a;
+        return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
+      };
+      ProxyTracerProvider2.prototype.getDelegate = function() {
+        var _a;
+        return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+      };
+      ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
+        this._delegate = delegate;
+      };
+      ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version, options) {
+        var _a;
+        return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+      };
+      return ProxyTracerProvider2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js
+var SamplingDecision;
+var init_SamplingResult = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js"() {
+    "use strict";
+    init_esm_shims();
+    (function(SamplingDecision2) {
+      SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
+      SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
+      SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+    })(SamplingDecision || (SamplingDecision = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
+var SpanKind;
+var init_span_kind = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/span_kind.js"() {
+    "use strict";
+    init_esm_shims();
+    (function(SpanKind2) {
+      SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+      SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+      SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+      SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+      SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+    })(SpanKind || (SpanKind = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/status.js
+var SpanStatusCode;
+var init_status = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/status.js"() {
+    "use strict";
+    init_esm_shims();
+    (function(SpanStatusCode2) {
+      SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+      SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+      SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+    })(SpanStatusCode || (SpanStatusCode = {}));
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js
+function validateKey(key) {
+  return VALID_KEY_REGEX.test(key);
+}
+function validateValue(value) {
+  return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+}
+var VALID_KEY_CHAR_RANGE, VALID_KEY, VALID_VENDOR_KEY, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX;
+var init_tracestate_validators = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js"() {
+    "use strict";
+    init_esm_shims();
+    VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+    VALID_KEY = "[a-z]" + VALID_KEY_CHAR_RANGE + "{0,255}";
+    VALID_VENDOR_KEY = "[a-z0-9]" + VALID_KEY_CHAR_RANGE + "{0,240}@[a-z]" + VALID_KEY_CHAR_RANGE + "{0,13}";
+    VALID_KEY_REGEX = new RegExp("^(?:" + VALID_KEY + "|" + VALID_VENDOR_KEY + ")$");
+    VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+    INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-impl.js
+var MAX_TRACE_STATE_ITEMS, MAX_TRACE_STATE_LEN, LIST_MEMBERS_SEPARATOR, LIST_MEMBER_KEY_VALUE_SPLITTER, TraceStateImpl;
+var init_tracestate_impl = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-impl.js"() {
+    "use strict";
+    init_esm_shims();
+    init_tracestate_validators();
+    MAX_TRACE_STATE_ITEMS = 32;
+    MAX_TRACE_STATE_LEN = 512;
+    LIST_MEMBERS_SEPARATOR = ",";
+    LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+    TraceStateImpl = /** @class */
+    function() {
+      function TraceStateImpl2(rawTraceState) {
+        this._internalState = /* @__PURE__ */ new Map();
+        if (rawTraceState)
+          this._parse(rawTraceState);
+      }
+      TraceStateImpl2.prototype.set = function(key, value) {
+        var traceState = this._clone();
+        if (traceState._internalState.has(key)) {
+          traceState._internalState.delete(key);
+        }
+        traceState._internalState.set(key, value);
+        return traceState;
+      };
+      TraceStateImpl2.prototype.unset = function(key) {
+        var traceState = this._clone();
+        traceState._internalState.delete(key);
+        return traceState;
+      };
+      TraceStateImpl2.prototype.get = function(key) {
+        return this._internalState.get(key);
+      };
+      TraceStateImpl2.prototype.serialize = function() {
+        var _this = this;
+        return this._keys().reduce(function(agg, key) {
+          agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + _this.get(key));
+          return agg;
+        }, []).join(LIST_MEMBERS_SEPARATOR);
+      };
+      TraceStateImpl2.prototype._parse = function(rawTraceState) {
+        if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+          return;
+        this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce(function(agg, part) {
+          var listMember = part.trim();
+          var i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+          if (i !== -1) {
+            var key = listMember.slice(0, i);
+            var value = listMember.slice(i + 1, part.length);
+            if (validateKey(key) && validateValue(value)) {
+              agg.set(key, value);
+            } else {
+            }
+          }
+          return agg;
+        }, /* @__PURE__ */ new Map());
+        if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+          this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
+        }
+      };
+      TraceStateImpl2.prototype._keys = function() {
+        return Array.from(this._internalState.keys()).reverse();
+      };
+      TraceStateImpl2.prototype._clone = function() {
+        var traceState = new TraceStateImpl2();
+        traceState._internalState = new Map(this._internalState);
+        return traceState;
+      };
+      return TraceStateImpl2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js
+function createTraceState(rawTraceState) {
+  return new TraceStateImpl(rawTraceState);
+}
+var init_utils2 = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js"() {
+    "use strict";
+    init_esm_shims();
+    init_tracestate_impl();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/context-api.js
+var context;
+var init_context_api = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/context-api.js"() {
+    "use strict";
+    init_esm_shims();
+    init_context2();
+    context = ContextAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/diag-api.js
+var diag2;
+var init_diag_api = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
+    "use strict";
+    init_esm_shims();
+    init_diag();
+    diag2 = DiagAPI.instance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
+var NoopMeterProvider, NOOP_METER_PROVIDER;
+var init_NoopMeterProvider = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js"() {
+    "use strict";
+    init_esm_shims();
+    init_NoopMeter();
+    NoopMeterProvider = /** @class */
+    function() {
+      function NoopMeterProvider2() {
+      }
+      NoopMeterProvider2.prototype.getMeter = function(_name, _version, _options) {
+        return NOOP_METER;
+      };
+      return NoopMeterProvider2;
+    }();
+    NOOP_METER_PROVIDER = new NoopMeterProvider();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/api/metrics.js
+var API_NAME3, MetricsAPI;
+var init_metrics = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/api/metrics.js"() {
+    "use strict";
+    init_esm_shims();
+    init_NoopMeterProvider();
+    init_global_utils();
+    init_diag();
+    API_NAME3 = "metrics";
+    MetricsAPI = /** @class */
+    function() {
+      function MetricsAPI2() {
+      }
+      MetricsAPI2.getInstance = function() {
+        if (!this._instance) {
+          this._instance = new MetricsAPI2();
+        }
+        return this._instance;
+      };
+      MetricsAPI2.prototype.setGlobalMeterProvider = function(provider) {
+        return registerGlobal(API_NAME3, provider, DiagAPI.instance());
+      };
+      MetricsAPI2.prototype.getMeterProvider = function() {
+        return getGlobal(API_NAME3) || NOOP_METER_PROVIDER;
+      };
+      MetricsAPI2.prototype.getMeter = function(name, version, options) {
+        return this.getMeterProvider().getMeter(name, version, options);
+      };
+      MetricsAPI2.prototype.disable = function() {
+        unregisterGlobal(API_NAME3, DiagAPI.instance());
+      };
+      return MetricsAPI2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/metrics-api.js
+var metrics;
+var init_metrics_api = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/metrics-api.js"() {
+    "use strict";
+    init_esm_shims();
+    init_metrics();
+    metrics = MetricsAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js
+var NoopTextMapPropagator;
+var init_NoopTextMapPropagator = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js"() {
+    "use strict";
+    init_esm_shims();
+    NoopTextMapPropagator = /** @class */
+    function() {
+      function NoopTextMapPropagator2() {
+      }
+      NoopTextMapPropagator2.prototype.inject = function(_context, _carrier) {
+      };
+      NoopTextMapPropagator2.prototype.extract = function(context2, _carrier) {
+        return context2;
+      };
+      NoopTextMapPropagator2.prototype.fields = function() {
+        return [];
+      };
+      return NoopTextMapPropagator2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js
+function getBaggage(context2) {
+  return context2.getValue(BAGGAGE_KEY) || void 0;
+}
+function getActiveBaggage() {
+  return getBaggage(ContextAPI.getInstance().active());
+}
+function setBaggage(context2, baggage) {
+  return context2.setValue(BAGGAGE_KEY, baggage);
+}
+function deleteBaggage(context2) {
+  return context2.deleteValue(BAGGAGE_KEY);
+}
+var BAGGAGE_KEY;
+var init_context_helpers = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js"() {
+    "use strict";
+    init_esm_shims();
+    init_context2();
+    init_context();
+    BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/api/propagation.js
+var API_NAME4, NOOP_TEXT_MAP_PROPAGATOR, PropagationAPI;
+var init_propagation = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/api/propagation.js"() {
+    "use strict";
+    init_esm_shims();
+    init_global_utils();
+    init_NoopTextMapPropagator();
+    init_TextMapPropagator();
+    init_context_helpers();
+    init_utils();
+    init_diag();
+    API_NAME4 = "propagation";
+    NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
+    PropagationAPI = /** @class */
+    function() {
+      function PropagationAPI2() {
+        this.createBaggage = createBaggage;
+        this.getBaggage = getBaggage;
+        this.getActiveBaggage = getActiveBaggage;
+        this.setBaggage = setBaggage;
+        this.deleteBaggage = deleteBaggage;
+      }
+      PropagationAPI2.getInstance = function() {
+        if (!this._instance) {
+          this._instance = new PropagationAPI2();
+        }
+        return this._instance;
+      };
+      PropagationAPI2.prototype.setGlobalPropagator = function(propagator) {
+        return registerGlobal(API_NAME4, propagator, DiagAPI.instance());
+      };
+      PropagationAPI2.prototype.inject = function(context2, carrier, setter) {
+        if (setter === void 0) {
+          setter = defaultTextMapSetter;
+        }
+        return this._getGlobalPropagator().inject(context2, carrier, setter);
+      };
+      PropagationAPI2.prototype.extract = function(context2, carrier, getter) {
+        if (getter === void 0) {
+          getter = defaultTextMapGetter;
+        }
+        return this._getGlobalPropagator().extract(context2, carrier, getter);
+      };
+      PropagationAPI2.prototype.fields = function() {
+        return this._getGlobalPropagator().fields();
+      };
+      PropagationAPI2.prototype.disable = function() {
+        unregisterGlobal(API_NAME4, DiagAPI.instance());
+      };
+      PropagationAPI2.prototype._getGlobalPropagator = function() {
+        return getGlobal(API_NAME4) || NOOP_TEXT_MAP_PROPAGATOR;
+      };
+      return PropagationAPI2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/propagation-api.js
+var propagation;
+var init_propagation_api = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/propagation-api.js"() {
+    "use strict";
+    init_esm_shims();
+    init_propagation();
+    propagation = PropagationAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/api/trace.js
+var API_NAME5, TraceAPI;
+var init_trace = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/api/trace.js"() {
+    "use strict";
+    init_esm_shims();
+    init_global_utils();
+    init_ProxyTracerProvider();
+    init_spancontext_utils();
+    init_context_utils();
+    init_diag();
+    API_NAME5 = "trace";
+    TraceAPI = /** @class */
+    function() {
+      function TraceAPI2() {
+        this._proxyTracerProvider = new ProxyTracerProvider();
+        this.wrapSpanContext = wrapSpanContext;
+        this.isSpanContextValid = isSpanContextValid;
+        this.deleteSpan = deleteSpan;
+        this.getSpan = getSpan;
+        this.getActiveSpan = getActiveSpan;
+        this.getSpanContext = getSpanContext;
+        this.setSpan = setSpan;
+        this.setSpanContext = setSpanContext;
+      }
+      TraceAPI2.getInstance = function() {
+        if (!this._instance) {
+          this._instance = new TraceAPI2();
+        }
+        return this._instance;
+      };
+      TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
+        var success = registerGlobal(API_NAME5, this._proxyTracerProvider, DiagAPI.instance());
+        if (success) {
+          this._proxyTracerProvider.setDelegate(provider);
+        }
+        return success;
+      };
+      TraceAPI2.prototype.getTracerProvider = function() {
+        return getGlobal(API_NAME5) || this._proxyTracerProvider;
+      };
+      TraceAPI2.prototype.getTracer = function(name, version) {
+        return this.getTracerProvider().getTracer(name, version);
+      };
+      TraceAPI2.prototype.disable = function() {
+        unregisterGlobal(API_NAME5, DiagAPI.instance());
+        this._proxyTracerProvider = new ProxyTracerProvider();
+      };
+      return TraceAPI2;
+    }();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/trace-api.js
+var trace;
+var init_trace_api = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/trace-api.js"() {
+    "use strict";
+    init_esm_shims();
+    init_trace();
+    trace = TraceAPI.getInstance();
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  DiagConsoleLogger: () => DiagConsoleLogger,
+  DiagLogLevel: () => DiagLogLevel,
+  INVALID_SPANID: () => INVALID_SPANID,
+  INVALID_SPAN_CONTEXT: () => INVALID_SPAN_CONTEXT,
+  INVALID_TRACEID: () => INVALID_TRACEID,
+  ProxyTracer: () => ProxyTracer,
+  ProxyTracerProvider: () => ProxyTracerProvider,
+  ROOT_CONTEXT: () => ROOT_CONTEXT,
+  SamplingDecision: () => SamplingDecision,
+  SpanKind: () => SpanKind,
+  SpanStatusCode: () => SpanStatusCode,
+  TraceFlags: () => TraceFlags,
+  ValueType: () => ValueType,
+  baggageEntryMetadataFromString: () => baggageEntryMetadataFromString,
+  context: () => context,
+  createContextKey: () => createContextKey,
+  createNoopMeter: () => createNoopMeter,
+  createTraceState: () => createTraceState,
+  default: () => esm_default,
+  defaultTextMapGetter: () => defaultTextMapGetter,
+  defaultTextMapSetter: () => defaultTextMapSetter,
+  diag: () => diag2,
+  isSpanContextValid: () => isSpanContextValid,
+  isValidSpanId: () => isValidSpanId,
+  isValidTraceId: () => isValidTraceId,
+  metrics: () => metrics,
+  propagation: () => propagation,
+  trace: () => trace
+});
+var esm_default;
+var init_esm = __esm({
+  "../../node_modules/@opentelemetry/api/build/esm/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_context();
+    init_consoleLogger();
+    init_types();
+    init_NoopMeter();
+    init_Metric();
+    init_TextMapPropagator();
+    init_ProxyTracer();
+    init_ProxyTracerProvider();
+    init_SamplingResult();
+    init_span_kind();
+    init_status();
+    init_trace_flags();
+    init_utils2();
+    init_spancontext_utils();
+    init_invalid_span_constants();
+    init_context_api();
+    init_diag_api();
+    init_metrics_api();
+    init_propagation_api();
+    init_trace_api();
+    esm_default = {
+      context,
+      diag: diag2,
+      metrics,
+      propagation,
+      trace
+    };
+  }
+});
+
+// ../../node_modules/@opentelemetry/semantic-conventions/build/esm/internal/utils.js
+// @__NO_SIDE_EFFECTS__
+function createConstMap(values) {
+  var res = {};
+  var len = values.length;
+  for (var lp = 0; lp < len; lp++) {
+    var val = values[lp];
+    if (val) {
+      res[String(val).toUpperCase().replace(/[-.]/g, "_")] = val;
+    }
+  }
+  return res;
+}
+var init_utils3 = __esm({
+  "../../node_modules/@opentelemetry/semantic-conventions/build/esm/internal/utils.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js
+var TMP_AWS_LAMBDA_INVOKED_ARN, TMP_DB_SYSTEM, TMP_DB_CONNECTION_STRING, TMP_DB_USER, TMP_DB_JDBC_DRIVER_CLASSNAME, TMP_DB_NAME, TMP_DB_STATEMENT, TMP_DB_OPERATION, TMP_DB_MSSQL_INSTANCE_NAME, TMP_DB_CASSANDRA_KEYSPACE, TMP_DB_CASSANDRA_PAGE_SIZE, TMP_DB_CASSANDRA_CONSISTENCY_LEVEL, TMP_DB_CASSANDRA_TABLE, TMP_DB_CASSANDRA_IDEMPOTENCE, TMP_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT, TMP_DB_CASSANDRA_COORDINATOR_ID, TMP_DB_CASSANDRA_COORDINATOR_DC, TMP_DB_HBASE_NAMESPACE, TMP_DB_REDIS_DATABASE_INDEX, TMP_DB_MONGODB_COLLECTION, TMP_DB_SQL_TABLE, TMP_EXCEPTION_TYPE, TMP_EXCEPTION_MESSAGE, TMP_EXCEPTION_STACKTRACE, TMP_EXCEPTION_ESCAPED, TMP_FAAS_TRIGGER, TMP_FAAS_EXECUTION, TMP_FAAS_DOCUMENT_COLLECTION, TMP_FAAS_DOCUMENT_OPERATION, TMP_FAAS_DOCUMENT_TIME, TMP_FAAS_DOCUMENT_NAME, TMP_FAAS_TIME, TMP_FAAS_CRON, TMP_FAAS_COLDSTART, TMP_FAAS_INVOKED_NAME, TMP_FAAS_INVOKED_PROVIDER, TMP_FAAS_INVOKED_REGION, TMP_NET_TRANSPORT, TMP_NET_PEER_IP, TMP_NET_PEER_PORT, TMP_NET_PEER_NAME, TMP_NET_HOST_IP, TMP_NET_HOST_PORT, TMP_NET_HOST_NAME, TMP_NET_HOST_CONNECTION_TYPE, TMP_NET_HOST_CONNECTION_SUBTYPE, TMP_NET_HOST_CARRIER_NAME, TMP_NET_HOST_CARRIER_MCC, TMP_NET_HOST_CARRIER_MNC, TMP_NET_HOST_CARRIER_ICC, TMP_PEER_SERVICE, TMP_ENDUSER_ID, TMP_ENDUSER_ROLE, TMP_ENDUSER_SCOPE, TMP_THREAD_ID, TMP_THREAD_NAME, TMP_CODE_FUNCTION, TMP_CODE_NAMESPACE, TMP_CODE_FILEPATH, TMP_CODE_LINENO, TMP_HTTP_METHOD, TMP_HTTP_URL, TMP_HTTP_TARGET, TMP_HTTP_HOST, TMP_HTTP_SCHEME, TMP_HTTP_STATUS_CODE, TMP_HTTP_FLAVOR, TMP_HTTP_USER_AGENT, TMP_HTTP_REQUEST_CONTENT_LENGTH, TMP_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED, TMP_HTTP_RESPONSE_CONTENT_LENGTH, TMP_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED, TMP_HTTP_SERVER_NAME, TMP_HTTP_ROUTE, TMP_HTTP_CLIENT_IP, TMP_AWS_DYNAMODB_TABLE_NAMES, TMP_AWS_DYNAMODB_CONSUMED_CAPACITY, TMP_AWS_DYNAMODB_ITEM_COLLECTION_METRICS, TMP_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY, TMP_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY, TMP_AWS_DYNAMODB_CONSISTENT_READ, TMP_AWS_DYNAMODB_PROJECTION, TMP_AWS_DYNAMODB_LIMIT, TMP_AWS_DYNAMODB_ATTRIBUTES_TO_GET, TMP_AWS_DYNAMODB_INDEX_NAME, TMP_AWS_DYNAMODB_SELECT, TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES, TMP_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES, TMP_AWS_DYNAMODB_EXCLUSIVE_START_TABLE, TMP_AWS_DYNAMODB_TABLE_COUNT, TMP_AWS_DYNAMODB_SCAN_FORWARD, TMP_AWS_DYNAMODB_SEGMENT, TMP_AWS_DYNAMODB_TOTAL_SEGMENTS, TMP_AWS_DYNAMODB_COUNT, TMP_AWS_DYNAMODB_SCANNED_COUNT, TMP_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS, TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES, TMP_MESSAGING_SYSTEM, TMP_MESSAGING_DESTINATION, TMP_MESSAGING_DESTINATION_KIND, TMP_MESSAGING_TEMP_DESTINATION, TMP_MESSAGING_PROTOCOL, TMP_MESSAGING_PROTOCOL_VERSION, TMP_MESSAGING_URL, TMP_MESSAGING_MESSAGE_ID, TMP_MESSAGING_CONVERSATION_ID, TMP_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES, TMP_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES, TMP_MESSAGING_OPERATION, TMP_MESSAGING_CONSUMER_ID, TMP_MESSAGING_RABBITMQ_ROUTING_KEY, TMP_MESSAGING_KAFKA_MESSAGE_KEY, TMP_MESSAGING_KAFKA_CONSUMER_GROUP, TMP_MESSAGING_KAFKA_CLIENT_ID, TMP_MESSAGING_KAFKA_PARTITION, TMP_MESSAGING_KAFKA_TOMBSTONE, TMP_RPC_SYSTEM, TMP_RPC_SERVICE, TMP_RPC_METHOD, TMP_RPC_GRPC_STATUS_CODE, TMP_RPC_JSONRPC_VERSION, TMP_RPC_JSONRPC_REQUEST_ID, TMP_RPC_JSONRPC_ERROR_CODE, TMP_RPC_JSONRPC_ERROR_MESSAGE, TMP_MESSAGE_TYPE, TMP_MESSAGE_ID, TMP_MESSAGE_COMPRESSED_SIZE, TMP_MESSAGE_UNCOMPRESSED_SIZE, SEMATTRS_AWS_LAMBDA_INVOKED_ARN, SEMATTRS_DB_SYSTEM, SEMATTRS_DB_CONNECTION_STRING, SEMATTRS_DB_USER, SEMATTRS_DB_JDBC_DRIVER_CLASSNAME, SEMATTRS_DB_NAME, SEMATTRS_DB_STATEMENT, SEMATTRS_DB_OPERATION, SEMATTRS_DB_MSSQL_INSTANCE_NAME, SEMATTRS_DB_CASSANDRA_KEYSPACE, SEMATTRS_DB_CASSANDRA_PAGE_SIZE, SEMATTRS_DB_CASSANDRA_CONSISTENCY_LEVEL, SEMATTRS_DB_CASSANDRA_TABLE, SEMATTRS_DB_CASSANDRA_IDEMPOTENCE, SEMATTRS_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT, SEMATTRS_DB_CASSANDRA_COORDINATOR_ID, SEMATTRS_DB_CASSANDRA_COORDINATOR_DC, SEMATTRS_DB_HBASE_NAMESPACE, SEMATTRS_DB_REDIS_DATABASE_INDEX, SEMATTRS_DB_MONGODB_COLLECTION, SEMATTRS_DB_SQL_TABLE, SEMATTRS_EXCEPTION_TYPE, SEMATTRS_EXCEPTION_MESSAGE, SEMATTRS_EXCEPTION_STACKTRACE, SEMATTRS_EXCEPTION_ESCAPED, SEMATTRS_FAAS_TRIGGER, SEMATTRS_FAAS_EXECUTION, SEMATTRS_FAAS_DOCUMENT_COLLECTION, SEMATTRS_FAAS_DOCUMENT_OPERATION, SEMATTRS_FAAS_DOCUMENT_TIME, SEMATTRS_FAAS_DOCUMENT_NAME, SEMATTRS_FAAS_TIME, SEMATTRS_FAAS_CRON, SEMATTRS_FAAS_COLDSTART, SEMATTRS_FAAS_INVOKED_NAME, SEMATTRS_FAAS_INVOKED_PROVIDER, SEMATTRS_FAAS_INVOKED_REGION, SEMATTRS_NET_TRANSPORT, SEMATTRS_NET_PEER_IP, SEMATTRS_NET_PEER_PORT, SEMATTRS_NET_PEER_NAME, SEMATTRS_NET_HOST_IP, SEMATTRS_NET_HOST_PORT, SEMATTRS_NET_HOST_NAME, SEMATTRS_NET_HOST_CONNECTION_TYPE, SEMATTRS_NET_HOST_CONNECTION_SUBTYPE, SEMATTRS_NET_HOST_CARRIER_NAME, SEMATTRS_NET_HOST_CARRIER_MCC, SEMATTRS_NET_HOST_CARRIER_MNC, SEMATTRS_NET_HOST_CARRIER_ICC, SEMATTRS_PEER_SERVICE, SEMATTRS_ENDUSER_ID, SEMATTRS_ENDUSER_ROLE, SEMATTRS_ENDUSER_SCOPE, SEMATTRS_THREAD_ID, SEMATTRS_THREAD_NAME, SEMATTRS_CODE_FUNCTION, SEMATTRS_CODE_NAMESPACE, SEMATTRS_CODE_FILEPATH, SEMATTRS_CODE_LINENO, SEMATTRS_HTTP_METHOD, SEMATTRS_HTTP_URL, SEMATTRS_HTTP_TARGET, SEMATTRS_HTTP_HOST, SEMATTRS_HTTP_SCHEME, SEMATTRS_HTTP_STATUS_CODE, SEMATTRS_HTTP_FLAVOR, SEMATTRS_HTTP_USER_AGENT, SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH, SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED, SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH, SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED, SEMATTRS_HTTP_SERVER_NAME, SEMATTRS_HTTP_ROUTE, SEMATTRS_HTTP_CLIENT_IP, SEMATTRS_AWS_DYNAMODB_TABLE_NAMES, SEMATTRS_AWS_DYNAMODB_CONSUMED_CAPACITY, SEMATTRS_AWS_DYNAMODB_ITEM_COLLECTION_METRICS, SEMATTRS_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY, SEMATTRS_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY, SEMATTRS_AWS_DYNAMODB_CONSISTENT_READ, SEMATTRS_AWS_DYNAMODB_PROJECTION, SEMATTRS_AWS_DYNAMODB_LIMIT, SEMATTRS_AWS_DYNAMODB_ATTRIBUTES_TO_GET, SEMATTRS_AWS_DYNAMODB_INDEX_NAME, SEMATTRS_AWS_DYNAMODB_SELECT, SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES, SEMATTRS_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES, SEMATTRS_AWS_DYNAMODB_EXCLUSIVE_START_TABLE, SEMATTRS_AWS_DYNAMODB_TABLE_COUNT, SEMATTRS_AWS_DYNAMODB_SCAN_FORWARD, SEMATTRS_AWS_DYNAMODB_SEGMENT, SEMATTRS_AWS_DYNAMODB_TOTAL_SEGMENTS, SEMATTRS_AWS_DYNAMODB_COUNT, SEMATTRS_AWS_DYNAMODB_SCANNED_COUNT, SEMATTRS_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS, SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES, SEMATTRS_MESSAGING_SYSTEM, SEMATTRS_MESSAGING_DESTINATION, SEMATTRS_MESSAGING_DESTINATION_KIND, SEMATTRS_MESSAGING_TEMP_DESTINATION, SEMATTRS_MESSAGING_PROTOCOL, SEMATTRS_MESSAGING_PROTOCOL_VERSION, SEMATTRS_MESSAGING_URL, SEMATTRS_MESSAGING_MESSAGE_ID, SEMATTRS_MESSAGING_CONVERSATION_ID, SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES, SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES, SEMATTRS_MESSAGING_OPERATION, SEMATTRS_MESSAGING_CONSUMER_ID, SEMATTRS_MESSAGING_RABBITMQ_ROUTING_KEY, SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY, SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP, SEMATTRS_MESSAGING_KAFKA_CLIENT_ID, SEMATTRS_MESSAGING_KAFKA_PARTITION, SEMATTRS_MESSAGING_KAFKA_TOMBSTONE, SEMATTRS_RPC_SYSTEM, SEMATTRS_RPC_SERVICE, SEMATTRS_RPC_METHOD, SEMATTRS_RPC_GRPC_STATUS_CODE, SEMATTRS_RPC_JSONRPC_VERSION, SEMATTRS_RPC_JSONRPC_REQUEST_ID, SEMATTRS_RPC_JSONRPC_ERROR_CODE, SEMATTRS_RPC_JSONRPC_ERROR_MESSAGE, SEMATTRS_MESSAGE_TYPE, SEMATTRS_MESSAGE_ID, SEMATTRS_MESSAGE_COMPRESSED_SIZE, SEMATTRS_MESSAGE_UNCOMPRESSED_SIZE, SemanticAttributes, TMP_DBSYSTEMVALUES_OTHER_SQL, TMP_DBSYSTEMVALUES_MSSQL, TMP_DBSYSTEMVALUES_MYSQL, TMP_DBSYSTEMVALUES_ORACLE, TMP_DBSYSTEMVALUES_DB2, TMP_DBSYSTEMVALUES_POSTGRESQL, TMP_DBSYSTEMVALUES_REDSHIFT, TMP_DBSYSTEMVALUES_HIVE, TMP_DBSYSTEMVALUES_CLOUDSCAPE, TMP_DBSYSTEMVALUES_HSQLDB, TMP_DBSYSTEMVALUES_PROGRESS, TMP_DBSYSTEMVALUES_MAXDB, TMP_DBSYSTEMVALUES_HANADB, TMP_DBSYSTEMVALUES_INGRES, TMP_DBSYSTEMVALUES_FIRSTSQL, TMP_DBSYSTEMVALUES_EDB, TMP_DBSYSTEMVALUES_CACHE, TMP_DBSYSTEMVALUES_ADABAS, TMP_DBSYSTEMVALUES_FIREBIRD, TMP_DBSYSTEMVALUES_DERBY, TMP_DBSYSTEMVALUES_FILEMAKER, TMP_DBSYSTEMVALUES_INFORMIX, TMP_DBSYSTEMVALUES_INSTANTDB, TMP_DBSYSTEMVALUES_INTERBASE, TMP_DBSYSTEMVALUES_MARIADB, TMP_DBSYSTEMVALUES_NETEZZA, TMP_DBSYSTEMVALUES_PERVASIVE, TMP_DBSYSTEMVALUES_POINTBASE, TMP_DBSYSTEMVALUES_SQLITE, TMP_DBSYSTEMVALUES_SYBASE, TMP_DBSYSTEMVALUES_TERADATA, TMP_DBSYSTEMVALUES_VERTICA, TMP_DBSYSTEMVALUES_H2, TMP_DBSYSTEMVALUES_COLDFUSION, TMP_DBSYSTEMVALUES_CASSANDRA, TMP_DBSYSTEMVALUES_HBASE, TMP_DBSYSTEMVALUES_MONGODB, TMP_DBSYSTEMVALUES_REDIS, TMP_DBSYSTEMVALUES_COUCHBASE, TMP_DBSYSTEMVALUES_COUCHDB, TMP_DBSYSTEMVALUES_COSMOSDB, TMP_DBSYSTEMVALUES_DYNAMODB, TMP_DBSYSTEMVALUES_NEO4J, TMP_DBSYSTEMVALUES_GEODE, TMP_DBSYSTEMVALUES_ELASTICSEARCH, TMP_DBSYSTEMVALUES_MEMCACHED, TMP_DBSYSTEMVALUES_COCKROACHDB, DBSYSTEMVALUES_OTHER_SQL, DBSYSTEMVALUES_MSSQL, DBSYSTEMVALUES_MYSQL, DBSYSTEMVALUES_ORACLE, DBSYSTEMVALUES_DB2, DBSYSTEMVALUES_POSTGRESQL, DBSYSTEMVALUES_REDSHIFT, DBSYSTEMVALUES_HIVE, DBSYSTEMVALUES_CLOUDSCAPE, DBSYSTEMVALUES_HSQLDB, DBSYSTEMVALUES_PROGRESS, DBSYSTEMVALUES_MAXDB, DBSYSTEMVALUES_HANADB, DBSYSTEMVALUES_INGRES, DBSYSTEMVALUES_FIRSTSQL, DBSYSTEMVALUES_EDB, DBSYSTEMVALUES_CACHE, DBSYSTEMVALUES_ADABAS, DBSYSTEMVALUES_FIREBIRD, DBSYSTEMVALUES_DERBY, DBSYSTEMVALUES_FILEMAKER, DBSYSTEMVALUES_INFORMIX, DBSYSTEMVALUES_INSTANTDB, DBSYSTEMVALUES_INTERBASE, DBSYSTEMVALUES_MARIADB, DBSYSTEMVALUES_NETEZZA, DBSYSTEMVALUES_PERVASIVE, DBSYSTEMVALUES_POINTBASE, DBSYSTEMVALUES_SQLITE, DBSYSTEMVALUES_SYBASE, DBSYSTEMVALUES_TERADATA, DBSYSTEMVALUES_VERTICA, DBSYSTEMVALUES_H2, DBSYSTEMVALUES_COLDFUSION, DBSYSTEMVALUES_CASSANDRA, DBSYSTEMVALUES_HBASE, DBSYSTEMVALUES_MONGODB, DBSYSTEMVALUES_REDIS, DBSYSTEMVALUES_COUCHBASE, DBSYSTEMVALUES_COUCHDB, DBSYSTEMVALUES_COSMOSDB, DBSYSTEMVALUES_DYNAMODB, DBSYSTEMVALUES_NEO4J, DBSYSTEMVALUES_GEODE, DBSYSTEMVALUES_ELASTICSEARCH, DBSYSTEMVALUES_MEMCACHED, DBSYSTEMVALUES_COCKROACHDB, DbSystemValues, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ALL, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ONE, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_TWO, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_THREE, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ANY, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL, DBCASSANDRACONSISTENCYLEVELVALUES_ALL, DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM, DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM, DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM, DBCASSANDRACONSISTENCYLEVELVALUES_ONE, DBCASSANDRACONSISTENCYLEVELVALUES_TWO, DBCASSANDRACONSISTENCYLEVELVALUES_THREE, DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE, DBCASSANDRACONSISTENCYLEVELVALUES_ANY, DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL, DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL, DbCassandraConsistencyLevelValues, TMP_FAASTRIGGERVALUES_DATASOURCE, TMP_FAASTRIGGERVALUES_HTTP, TMP_FAASTRIGGERVALUES_PUBSUB, TMP_FAASTRIGGERVALUES_TIMER, TMP_FAASTRIGGERVALUES_OTHER, FAASTRIGGERVALUES_DATASOURCE, FAASTRIGGERVALUES_HTTP, FAASTRIGGERVALUES_PUBSUB, FAASTRIGGERVALUES_TIMER, FAASTRIGGERVALUES_OTHER, FaasTriggerValues, TMP_FAASDOCUMENTOPERATIONVALUES_INSERT, TMP_FAASDOCUMENTOPERATIONVALUES_EDIT, TMP_FAASDOCUMENTOPERATIONVALUES_DELETE, FAASDOCUMENTOPERATIONVALUES_INSERT, FAASDOCUMENTOPERATIONVALUES_EDIT, FAASDOCUMENTOPERATIONVALUES_DELETE, FaasDocumentOperationValues, TMP_FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD, TMP_FAASINVOKEDPROVIDERVALUES_AWS, TMP_FAASINVOKEDPROVIDERVALUES_AZURE, TMP_FAASINVOKEDPROVIDERVALUES_GCP, FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD, FAASINVOKEDPROVIDERVALUES_AWS, FAASINVOKEDPROVIDERVALUES_AZURE, FAASINVOKEDPROVIDERVALUES_GCP, FaasInvokedProviderValues, TMP_NETTRANSPORTVALUES_IP_TCP, TMP_NETTRANSPORTVALUES_IP_UDP, TMP_NETTRANSPORTVALUES_IP, TMP_NETTRANSPORTVALUES_UNIX, TMP_NETTRANSPORTVALUES_PIPE, TMP_NETTRANSPORTVALUES_INPROC, TMP_NETTRANSPORTVALUES_OTHER, NETTRANSPORTVALUES_IP_TCP, NETTRANSPORTVALUES_IP_UDP, NETTRANSPORTVALUES_IP, NETTRANSPORTVALUES_UNIX, NETTRANSPORTVALUES_PIPE, NETTRANSPORTVALUES_INPROC, NETTRANSPORTVALUES_OTHER, NetTransportValues, TMP_NETHOSTCONNECTIONTYPEVALUES_WIFI, TMP_NETHOSTCONNECTIONTYPEVALUES_WIRED, TMP_NETHOSTCONNECTIONTYPEVALUES_CELL, TMP_NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE, TMP_NETHOSTCONNECTIONTYPEVALUES_UNKNOWN, NETHOSTCONNECTIONTYPEVALUES_WIFI, NETHOSTCONNECTIONTYPEVALUES_WIRED, NETHOSTCONNECTIONTYPEVALUES_CELL, NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE, NETHOSTCONNECTIONTYPEVALUES_UNKNOWN, NetHostConnectionTypeValues, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GPRS, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EDGE, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_UMTS, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IDEN, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GSM, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NR, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA, NETHOSTCONNECTIONSUBTYPEVALUES_GPRS, NETHOSTCONNECTIONSUBTYPEVALUES_EDGE, NETHOSTCONNECTIONSUBTYPEVALUES_UMTS, NETHOSTCONNECTIONSUBTYPEVALUES_CDMA, NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0, NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A, NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT, NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA, NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA, NETHOSTCONNECTIONSUBTYPEVALUES_HSPA, NETHOSTCONNECTIONSUBTYPEVALUES_IDEN, NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B, NETHOSTCONNECTIONSUBTYPEVALUES_LTE, NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD, NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP, NETHOSTCONNECTIONSUBTYPEVALUES_GSM, NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA, NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN, NETHOSTCONNECTIONSUBTYPEVALUES_NR, NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA, NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA, NetHostConnectionSubtypeValues, TMP_HTTPFLAVORVALUES_HTTP_1_0, TMP_HTTPFLAVORVALUES_HTTP_1_1, TMP_HTTPFLAVORVALUES_HTTP_2_0, TMP_HTTPFLAVORVALUES_SPDY, TMP_HTTPFLAVORVALUES_QUIC, HTTPFLAVORVALUES_HTTP_1_0, HTTPFLAVORVALUES_HTTP_1_1, HTTPFLAVORVALUES_HTTP_2_0, HTTPFLAVORVALUES_SPDY, HTTPFLAVORVALUES_QUIC, HttpFlavorValues, TMP_MESSAGINGDESTINATIONKINDVALUES_QUEUE, TMP_MESSAGINGDESTINATIONKINDVALUES_TOPIC, MESSAGINGDESTINATIONKINDVALUES_QUEUE, MESSAGINGDESTINATIONKINDVALUES_TOPIC, MessagingDestinationKindValues, TMP_MESSAGINGOPERATIONVALUES_RECEIVE, TMP_MESSAGINGOPERATIONVALUES_PROCESS, MESSAGINGOPERATIONVALUES_RECEIVE, MESSAGINGOPERATIONVALUES_PROCESS, MessagingOperationValues, TMP_RPCGRPCSTATUSCODEVALUES_OK, TMP_RPCGRPCSTATUSCODEVALUES_CANCELLED, TMP_RPCGRPCSTATUSCODEVALUES_UNKNOWN, TMP_RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT, TMP_RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED, TMP_RPCGRPCSTATUSCODEVALUES_NOT_FOUND, TMP_RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS, TMP_RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED, TMP_RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED, TMP_RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION, TMP_RPCGRPCSTATUSCODEVALUES_ABORTED, TMP_RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE, TMP_RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED, TMP_RPCGRPCSTATUSCODEVALUES_INTERNAL, TMP_RPCGRPCSTATUSCODEVALUES_UNAVAILABLE, TMP_RPCGRPCSTATUSCODEVALUES_DATA_LOSS, TMP_RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED, RPCGRPCSTATUSCODEVALUES_OK, RPCGRPCSTATUSCODEVALUES_CANCELLED, RPCGRPCSTATUSCODEVALUES_UNKNOWN, RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT, RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED, RPCGRPCSTATUSCODEVALUES_NOT_FOUND, RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS, RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED, RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED, RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION, RPCGRPCSTATUSCODEVALUES_ABORTED, RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE, RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED, RPCGRPCSTATUSCODEVALUES_INTERNAL, RPCGRPCSTATUSCODEVALUES_UNAVAILABLE, RPCGRPCSTATUSCODEVALUES_DATA_LOSS, RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED, RpcGrpcStatusCodeValues, TMP_MESSAGETYPEVALUES_SENT, TMP_MESSAGETYPEVALUES_RECEIVED, MESSAGETYPEVALUES_SENT, MESSAGETYPEVALUES_RECEIVED, MessageTypeValues;
+var init_SemanticAttributes = __esm({
+  "../../node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js"() {
+    "use strict";
+    init_esm_shims();
+    init_utils3();
+    TMP_AWS_LAMBDA_INVOKED_ARN = "aws.lambda.invoked_arn";
+    TMP_DB_SYSTEM = "db.system";
+    TMP_DB_CONNECTION_STRING = "db.connection_string";
+    TMP_DB_USER = "db.user";
+    TMP_DB_JDBC_DRIVER_CLASSNAME = "db.jdbc.driver_classname";
+    TMP_DB_NAME = "db.name";
+    TMP_DB_STATEMENT = "db.statement";
+    TMP_DB_OPERATION = "db.operation";
+    TMP_DB_MSSQL_INSTANCE_NAME = "db.mssql.instance_name";
+    TMP_DB_CASSANDRA_KEYSPACE = "db.cassandra.keyspace";
+    TMP_DB_CASSANDRA_PAGE_SIZE = "db.cassandra.page_size";
+    TMP_DB_CASSANDRA_CONSISTENCY_LEVEL = "db.cassandra.consistency_level";
+    TMP_DB_CASSANDRA_TABLE = "db.cassandra.table";
+    TMP_DB_CASSANDRA_IDEMPOTENCE = "db.cassandra.idempotence";
+    TMP_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT = "db.cassandra.speculative_execution_count";
+    TMP_DB_CASSANDRA_COORDINATOR_ID = "db.cassandra.coordinator.id";
+    TMP_DB_CASSANDRA_COORDINATOR_DC = "db.cassandra.coordinator.dc";
+    TMP_DB_HBASE_NAMESPACE = "db.hbase.namespace";
+    TMP_DB_REDIS_DATABASE_INDEX = "db.redis.database_index";
+    TMP_DB_MONGODB_COLLECTION = "db.mongodb.collection";
+    TMP_DB_SQL_TABLE = "db.sql.table";
+    TMP_EXCEPTION_TYPE = "exception.type";
+    TMP_EXCEPTION_MESSAGE = "exception.message";
+    TMP_EXCEPTION_STACKTRACE = "exception.stacktrace";
+    TMP_EXCEPTION_ESCAPED = "exception.escaped";
+    TMP_FAAS_TRIGGER = "faas.trigger";
+    TMP_FAAS_EXECUTION = "faas.execution";
+    TMP_FAAS_DOCUMENT_COLLECTION = "faas.document.collection";
+    TMP_FAAS_DOCUMENT_OPERATION = "faas.document.operation";
+    TMP_FAAS_DOCUMENT_TIME = "faas.document.time";
+    TMP_FAAS_DOCUMENT_NAME = "faas.document.name";
+    TMP_FAAS_TIME = "faas.time";
+    TMP_FAAS_CRON = "faas.cron";
+    TMP_FAAS_COLDSTART = "faas.coldstart";
+    TMP_FAAS_INVOKED_NAME = "faas.invoked_name";
+    TMP_FAAS_INVOKED_PROVIDER = "faas.invoked_provider";
+    TMP_FAAS_INVOKED_REGION = "faas.invoked_region";
+    TMP_NET_TRANSPORT = "net.transport";
+    TMP_NET_PEER_IP = "net.peer.ip";
+    TMP_NET_PEER_PORT = "net.peer.port";
+    TMP_NET_PEER_NAME = "net.peer.name";
+    TMP_NET_HOST_IP = "net.host.ip";
+    TMP_NET_HOST_PORT = "net.host.port";
+    TMP_NET_HOST_NAME = "net.host.name";
+    TMP_NET_HOST_CONNECTION_TYPE = "net.host.connection.type";
+    TMP_NET_HOST_CONNECTION_SUBTYPE = "net.host.connection.subtype";
+    TMP_NET_HOST_CARRIER_NAME = "net.host.carrier.name";
+    TMP_NET_HOST_CARRIER_MCC = "net.host.carrier.mcc";
+    TMP_NET_HOST_CARRIER_MNC = "net.host.carrier.mnc";
+    TMP_NET_HOST_CARRIER_ICC = "net.host.carrier.icc";
+    TMP_PEER_SERVICE = "peer.service";
+    TMP_ENDUSER_ID = "enduser.id";
+    TMP_ENDUSER_ROLE = "enduser.role";
+    TMP_ENDUSER_SCOPE = "enduser.scope";
+    TMP_THREAD_ID = "thread.id";
+    TMP_THREAD_NAME = "thread.name";
+    TMP_CODE_FUNCTION = "code.function";
+    TMP_CODE_NAMESPACE = "code.namespace";
+    TMP_CODE_FILEPATH = "code.filepath";
+    TMP_CODE_LINENO = "code.lineno";
+    TMP_HTTP_METHOD = "http.method";
+    TMP_HTTP_URL = "http.url";
+    TMP_HTTP_TARGET = "http.target";
+    TMP_HTTP_HOST = "http.host";
+    TMP_HTTP_SCHEME = "http.scheme";
+    TMP_HTTP_STATUS_CODE = "http.status_code";
+    TMP_HTTP_FLAVOR = "http.flavor";
+    TMP_HTTP_USER_AGENT = "http.user_agent";
+    TMP_HTTP_REQUEST_CONTENT_LENGTH = "http.request_content_length";
+    TMP_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED = "http.request_content_length_uncompressed";
+    TMP_HTTP_RESPONSE_CONTENT_LENGTH = "http.response_content_length";
+    TMP_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED = "http.response_content_length_uncompressed";
+    TMP_HTTP_SERVER_NAME = "http.server_name";
+    TMP_HTTP_ROUTE = "http.route";
+    TMP_HTTP_CLIENT_IP = "http.client_ip";
+    TMP_AWS_DYNAMODB_TABLE_NAMES = "aws.dynamodb.table_names";
+    TMP_AWS_DYNAMODB_CONSUMED_CAPACITY = "aws.dynamodb.consumed_capacity";
+    TMP_AWS_DYNAMODB_ITEM_COLLECTION_METRICS = "aws.dynamodb.item_collection_metrics";
+    TMP_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY = "aws.dynamodb.provisioned_read_capacity";
+    TMP_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY = "aws.dynamodb.provisioned_write_capacity";
+    TMP_AWS_DYNAMODB_CONSISTENT_READ = "aws.dynamodb.consistent_read";
+    TMP_AWS_DYNAMODB_PROJECTION = "aws.dynamodb.projection";
+    TMP_AWS_DYNAMODB_LIMIT = "aws.dynamodb.limit";
+    TMP_AWS_DYNAMODB_ATTRIBUTES_TO_GET = "aws.dynamodb.attributes_to_get";
+    TMP_AWS_DYNAMODB_INDEX_NAME = "aws.dynamodb.index_name";
+    TMP_AWS_DYNAMODB_SELECT = "aws.dynamodb.select";
+    TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES = "aws.dynamodb.global_secondary_indexes";
+    TMP_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES = "aws.dynamodb.local_secondary_indexes";
+    TMP_AWS_DYNAMODB_EXCLUSIVE_START_TABLE = "aws.dynamodb.exclusive_start_table";
+    TMP_AWS_DYNAMODB_TABLE_COUNT = "aws.dynamodb.table_count";
+    TMP_AWS_DYNAMODB_SCAN_FORWARD = "aws.dynamodb.scan_forward";
+    TMP_AWS_DYNAMODB_SEGMENT = "aws.dynamodb.segment";
+    TMP_AWS_DYNAMODB_TOTAL_SEGMENTS = "aws.dynamodb.total_segments";
+    TMP_AWS_DYNAMODB_COUNT = "aws.dynamodb.count";
+    TMP_AWS_DYNAMODB_SCANNED_COUNT = "aws.dynamodb.scanned_count";
+    TMP_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS = "aws.dynamodb.attribute_definitions";
+    TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES = "aws.dynamodb.global_secondary_index_updates";
+    TMP_MESSAGING_SYSTEM = "messaging.system";
+    TMP_MESSAGING_DESTINATION = "messaging.destination";
+    TMP_MESSAGING_DESTINATION_KIND = "messaging.destination_kind";
+    TMP_MESSAGING_TEMP_DESTINATION = "messaging.temp_destination";
+    TMP_MESSAGING_PROTOCOL = "messaging.protocol";
+    TMP_MESSAGING_PROTOCOL_VERSION = "messaging.protocol_version";
+    TMP_MESSAGING_URL = "messaging.url";
+    TMP_MESSAGING_MESSAGE_ID = "messaging.message_id";
+    TMP_MESSAGING_CONVERSATION_ID = "messaging.conversation_id";
+    TMP_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES = "messaging.message_payload_size_bytes";
+    TMP_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES = "messaging.message_payload_compressed_size_bytes";
+    TMP_MESSAGING_OPERATION = "messaging.operation";
+    TMP_MESSAGING_CONSUMER_ID = "messaging.consumer_id";
+    TMP_MESSAGING_RABBITMQ_ROUTING_KEY = "messaging.rabbitmq.routing_key";
+    TMP_MESSAGING_KAFKA_MESSAGE_KEY = "messaging.kafka.message_key";
+    TMP_MESSAGING_KAFKA_CONSUMER_GROUP = "messaging.kafka.consumer_group";
+    TMP_MESSAGING_KAFKA_CLIENT_ID = "messaging.kafka.client_id";
+    TMP_MESSAGING_KAFKA_PARTITION = "messaging.kafka.partition";
+    TMP_MESSAGING_KAFKA_TOMBSTONE = "messaging.kafka.tombstone";
+    TMP_RPC_SYSTEM = "rpc.system";
+    TMP_RPC_SERVICE = "rpc.service";
+    TMP_RPC_METHOD = "rpc.method";
+    TMP_RPC_GRPC_STATUS_CODE = "rpc.grpc.status_code";
+    TMP_RPC_JSONRPC_VERSION = "rpc.jsonrpc.version";
+    TMP_RPC_JSONRPC_REQUEST_ID = "rpc.jsonrpc.request_id";
+    TMP_RPC_JSONRPC_ERROR_CODE = "rpc.jsonrpc.error_code";
+    TMP_RPC_JSONRPC_ERROR_MESSAGE = "rpc.jsonrpc.error_message";
+    TMP_MESSAGE_TYPE = "message.type";
+    TMP_MESSAGE_ID = "message.id";
+    TMP_MESSAGE_COMPRESSED_SIZE = "message.compressed_size";
+    TMP_MESSAGE_UNCOMPRESSED_SIZE = "message.uncompressed_size";
+    SEMATTRS_AWS_LAMBDA_INVOKED_ARN = TMP_AWS_LAMBDA_INVOKED_ARN;
+    SEMATTRS_DB_SYSTEM = TMP_DB_SYSTEM;
+    SEMATTRS_DB_CONNECTION_STRING = TMP_DB_CONNECTION_STRING;
+    SEMATTRS_DB_USER = TMP_DB_USER;
+    SEMATTRS_DB_JDBC_DRIVER_CLASSNAME = TMP_DB_JDBC_DRIVER_CLASSNAME;
+    SEMATTRS_DB_NAME = TMP_DB_NAME;
+    SEMATTRS_DB_STATEMENT = TMP_DB_STATEMENT;
+    SEMATTRS_DB_OPERATION = TMP_DB_OPERATION;
+    SEMATTRS_DB_MSSQL_INSTANCE_NAME = TMP_DB_MSSQL_INSTANCE_NAME;
+    SEMATTRS_DB_CASSANDRA_KEYSPACE = TMP_DB_CASSANDRA_KEYSPACE;
+    SEMATTRS_DB_CASSANDRA_PAGE_SIZE = TMP_DB_CASSANDRA_PAGE_SIZE;
+    SEMATTRS_DB_CASSANDRA_CONSISTENCY_LEVEL = TMP_DB_CASSANDRA_CONSISTENCY_LEVEL;
+    SEMATTRS_DB_CASSANDRA_TABLE = TMP_DB_CASSANDRA_TABLE;
+    SEMATTRS_DB_CASSANDRA_IDEMPOTENCE = TMP_DB_CASSANDRA_IDEMPOTENCE;
+    SEMATTRS_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT = TMP_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT;
+    SEMATTRS_DB_CASSANDRA_COORDINATOR_ID = TMP_DB_CASSANDRA_COORDINATOR_ID;
+    SEMATTRS_DB_CASSANDRA_COORDINATOR_DC = TMP_DB_CASSANDRA_COORDINATOR_DC;
+    SEMATTRS_DB_HBASE_NAMESPACE = TMP_DB_HBASE_NAMESPACE;
+    SEMATTRS_DB_REDIS_DATABASE_INDEX = TMP_DB_REDIS_DATABASE_INDEX;
+    SEMATTRS_DB_MONGODB_COLLECTION = TMP_DB_MONGODB_COLLECTION;
+    SEMATTRS_DB_SQL_TABLE = TMP_DB_SQL_TABLE;
+    SEMATTRS_EXCEPTION_TYPE = TMP_EXCEPTION_TYPE;
+    SEMATTRS_EXCEPTION_MESSAGE = TMP_EXCEPTION_MESSAGE;
+    SEMATTRS_EXCEPTION_STACKTRACE = TMP_EXCEPTION_STACKTRACE;
+    SEMATTRS_EXCEPTION_ESCAPED = TMP_EXCEPTION_ESCAPED;
+    SEMATTRS_FAAS_TRIGGER = TMP_FAAS_TRIGGER;
+    SEMATTRS_FAAS_EXECUTION = TMP_FAAS_EXECUTION;
+    SEMATTRS_FAAS_DOCUMENT_COLLECTION = TMP_FAAS_DOCUMENT_COLLECTION;
+    SEMATTRS_FAAS_DOCUMENT_OPERATION = TMP_FAAS_DOCUMENT_OPERATION;
+    SEMATTRS_FAAS_DOCUMENT_TIME = TMP_FAAS_DOCUMENT_TIME;
+    SEMATTRS_FAAS_DOCUMENT_NAME = TMP_FAAS_DOCUMENT_NAME;
+    SEMATTRS_FAAS_TIME = TMP_FAAS_TIME;
+    SEMATTRS_FAAS_CRON = TMP_FAAS_CRON;
+    SEMATTRS_FAAS_COLDSTART = TMP_FAAS_COLDSTART;
+    SEMATTRS_FAAS_INVOKED_NAME = TMP_FAAS_INVOKED_NAME;
+    SEMATTRS_FAAS_INVOKED_PROVIDER = TMP_FAAS_INVOKED_PROVIDER;
+    SEMATTRS_FAAS_INVOKED_REGION = TMP_FAAS_INVOKED_REGION;
+    SEMATTRS_NET_TRANSPORT = TMP_NET_TRANSPORT;
+    SEMATTRS_NET_PEER_IP = TMP_NET_PEER_IP;
+    SEMATTRS_NET_PEER_PORT = TMP_NET_PEER_PORT;
+    SEMATTRS_NET_PEER_NAME = TMP_NET_PEER_NAME;
+    SEMATTRS_NET_HOST_IP = TMP_NET_HOST_IP;
+    SEMATTRS_NET_HOST_PORT = TMP_NET_HOST_PORT;
+    SEMATTRS_NET_HOST_NAME = TMP_NET_HOST_NAME;
+    SEMATTRS_NET_HOST_CONNECTION_TYPE = TMP_NET_HOST_CONNECTION_TYPE;
+    SEMATTRS_NET_HOST_CONNECTION_SUBTYPE = TMP_NET_HOST_CONNECTION_SUBTYPE;
+    SEMATTRS_NET_HOST_CARRIER_NAME = TMP_NET_HOST_CARRIER_NAME;
+    SEMATTRS_NET_HOST_CARRIER_MCC = TMP_NET_HOST_CARRIER_MCC;
+    SEMATTRS_NET_HOST_CARRIER_MNC = TMP_NET_HOST_CARRIER_MNC;
+    SEMATTRS_NET_HOST_CARRIER_ICC = TMP_NET_HOST_CARRIER_ICC;
+    SEMATTRS_PEER_SERVICE = TMP_PEER_SERVICE;
+    SEMATTRS_ENDUSER_ID = TMP_ENDUSER_ID;
+    SEMATTRS_ENDUSER_ROLE = TMP_ENDUSER_ROLE;
+    SEMATTRS_ENDUSER_SCOPE = TMP_ENDUSER_SCOPE;
+    SEMATTRS_THREAD_ID = TMP_THREAD_ID;
+    SEMATTRS_THREAD_NAME = TMP_THREAD_NAME;
+    SEMATTRS_CODE_FUNCTION = TMP_CODE_FUNCTION;
+    SEMATTRS_CODE_NAMESPACE = TMP_CODE_NAMESPACE;
+    SEMATTRS_CODE_FILEPATH = TMP_CODE_FILEPATH;
+    SEMATTRS_CODE_LINENO = TMP_CODE_LINENO;
+    SEMATTRS_HTTP_METHOD = TMP_HTTP_METHOD;
+    SEMATTRS_HTTP_URL = TMP_HTTP_URL;
+    SEMATTRS_HTTP_TARGET = TMP_HTTP_TARGET;
+    SEMATTRS_HTTP_HOST = TMP_HTTP_HOST;
+    SEMATTRS_HTTP_SCHEME = TMP_HTTP_SCHEME;
+    SEMATTRS_HTTP_STATUS_CODE = TMP_HTTP_STATUS_CODE;
+    SEMATTRS_HTTP_FLAVOR = TMP_HTTP_FLAVOR;
+    SEMATTRS_HTTP_USER_AGENT = TMP_HTTP_USER_AGENT;
+    SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH = TMP_HTTP_REQUEST_CONTENT_LENGTH;
+    SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED = TMP_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED;
+    SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH = TMP_HTTP_RESPONSE_CONTENT_LENGTH;
+    SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED = TMP_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED;
+    SEMATTRS_HTTP_SERVER_NAME = TMP_HTTP_SERVER_NAME;
+    SEMATTRS_HTTP_ROUTE = TMP_HTTP_ROUTE;
+    SEMATTRS_HTTP_CLIENT_IP = TMP_HTTP_CLIENT_IP;
+    SEMATTRS_AWS_DYNAMODB_TABLE_NAMES = TMP_AWS_DYNAMODB_TABLE_NAMES;
+    SEMATTRS_AWS_DYNAMODB_CONSUMED_CAPACITY = TMP_AWS_DYNAMODB_CONSUMED_CAPACITY;
+    SEMATTRS_AWS_DYNAMODB_ITEM_COLLECTION_METRICS = TMP_AWS_DYNAMODB_ITEM_COLLECTION_METRICS;
+    SEMATTRS_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY = TMP_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY;
+    SEMATTRS_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY = TMP_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY;
+    SEMATTRS_AWS_DYNAMODB_CONSISTENT_READ = TMP_AWS_DYNAMODB_CONSISTENT_READ;
+    SEMATTRS_AWS_DYNAMODB_PROJECTION = TMP_AWS_DYNAMODB_PROJECTION;
+    SEMATTRS_AWS_DYNAMODB_LIMIT = TMP_AWS_DYNAMODB_LIMIT;
+    SEMATTRS_AWS_DYNAMODB_ATTRIBUTES_TO_GET = TMP_AWS_DYNAMODB_ATTRIBUTES_TO_GET;
+    SEMATTRS_AWS_DYNAMODB_INDEX_NAME = TMP_AWS_DYNAMODB_INDEX_NAME;
+    SEMATTRS_AWS_DYNAMODB_SELECT = TMP_AWS_DYNAMODB_SELECT;
+    SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES = TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES;
+    SEMATTRS_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES = TMP_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES;
+    SEMATTRS_AWS_DYNAMODB_EXCLUSIVE_START_TABLE = TMP_AWS_DYNAMODB_EXCLUSIVE_START_TABLE;
+    SEMATTRS_AWS_DYNAMODB_TABLE_COUNT = TMP_AWS_DYNAMODB_TABLE_COUNT;
+    SEMATTRS_AWS_DYNAMODB_SCAN_FORWARD = TMP_AWS_DYNAMODB_SCAN_FORWARD;
+    SEMATTRS_AWS_DYNAMODB_SEGMENT = TMP_AWS_DYNAMODB_SEGMENT;
+    SEMATTRS_AWS_DYNAMODB_TOTAL_SEGMENTS = TMP_AWS_DYNAMODB_TOTAL_SEGMENTS;
+    SEMATTRS_AWS_DYNAMODB_COUNT = TMP_AWS_DYNAMODB_COUNT;
+    SEMATTRS_AWS_DYNAMODB_SCANNED_COUNT = TMP_AWS_DYNAMODB_SCANNED_COUNT;
+    SEMATTRS_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS = TMP_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS;
+    SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES = TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES;
+    SEMATTRS_MESSAGING_SYSTEM = TMP_MESSAGING_SYSTEM;
+    SEMATTRS_MESSAGING_DESTINATION = TMP_MESSAGING_DESTINATION;
+    SEMATTRS_MESSAGING_DESTINATION_KIND = TMP_MESSAGING_DESTINATION_KIND;
+    SEMATTRS_MESSAGING_TEMP_DESTINATION = TMP_MESSAGING_TEMP_DESTINATION;
+    SEMATTRS_MESSAGING_PROTOCOL = TMP_MESSAGING_PROTOCOL;
+    SEMATTRS_MESSAGING_PROTOCOL_VERSION = TMP_MESSAGING_PROTOCOL_VERSION;
+    SEMATTRS_MESSAGING_URL = TMP_MESSAGING_URL;
+    SEMATTRS_MESSAGING_MESSAGE_ID = TMP_MESSAGING_MESSAGE_ID;
+    SEMATTRS_MESSAGING_CONVERSATION_ID = TMP_MESSAGING_CONVERSATION_ID;
+    SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES = TMP_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES;
+    SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES = TMP_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES;
+    SEMATTRS_MESSAGING_OPERATION = TMP_MESSAGING_OPERATION;
+    SEMATTRS_MESSAGING_CONSUMER_ID = TMP_MESSAGING_CONSUMER_ID;
+    SEMATTRS_MESSAGING_RABBITMQ_ROUTING_KEY = TMP_MESSAGING_RABBITMQ_ROUTING_KEY;
+    SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY = TMP_MESSAGING_KAFKA_MESSAGE_KEY;
+    SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP = TMP_MESSAGING_KAFKA_CONSUMER_GROUP;
+    SEMATTRS_MESSAGING_KAFKA_CLIENT_ID = TMP_MESSAGING_KAFKA_CLIENT_ID;
+    SEMATTRS_MESSAGING_KAFKA_PARTITION = TMP_MESSAGING_KAFKA_PARTITION;
+    SEMATTRS_MESSAGING_KAFKA_TOMBSTONE = TMP_MESSAGING_KAFKA_TOMBSTONE;
+    SEMATTRS_RPC_SYSTEM = TMP_RPC_SYSTEM;
+    SEMATTRS_RPC_SERVICE = TMP_RPC_SERVICE;
+    SEMATTRS_RPC_METHOD = TMP_RPC_METHOD;
+    SEMATTRS_RPC_GRPC_STATUS_CODE = TMP_RPC_GRPC_STATUS_CODE;
+    SEMATTRS_RPC_JSONRPC_VERSION = TMP_RPC_JSONRPC_VERSION;
+    SEMATTRS_RPC_JSONRPC_REQUEST_ID = TMP_RPC_JSONRPC_REQUEST_ID;
+    SEMATTRS_RPC_JSONRPC_ERROR_CODE = TMP_RPC_JSONRPC_ERROR_CODE;
+    SEMATTRS_RPC_JSONRPC_ERROR_MESSAGE = TMP_RPC_JSONRPC_ERROR_MESSAGE;
+    SEMATTRS_MESSAGE_TYPE = TMP_MESSAGE_TYPE;
+    SEMATTRS_MESSAGE_ID = TMP_MESSAGE_ID;
+    SEMATTRS_MESSAGE_COMPRESSED_SIZE = TMP_MESSAGE_COMPRESSED_SIZE;
+    SEMATTRS_MESSAGE_UNCOMPRESSED_SIZE = TMP_MESSAGE_UNCOMPRESSED_SIZE;
+    SemanticAttributes = /* @__PURE__ */ createConstMap([
+      TMP_AWS_LAMBDA_INVOKED_ARN,
+      TMP_DB_SYSTEM,
+      TMP_DB_CONNECTION_STRING,
+      TMP_DB_USER,
+      TMP_DB_JDBC_DRIVER_CLASSNAME,
+      TMP_DB_NAME,
+      TMP_DB_STATEMENT,
+      TMP_DB_OPERATION,
+      TMP_DB_MSSQL_INSTANCE_NAME,
+      TMP_DB_CASSANDRA_KEYSPACE,
+      TMP_DB_CASSANDRA_PAGE_SIZE,
+      TMP_DB_CASSANDRA_CONSISTENCY_LEVEL,
+      TMP_DB_CASSANDRA_TABLE,
+      TMP_DB_CASSANDRA_IDEMPOTENCE,
+      TMP_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT,
+      TMP_DB_CASSANDRA_COORDINATOR_ID,
+      TMP_DB_CASSANDRA_COORDINATOR_DC,
+      TMP_DB_HBASE_NAMESPACE,
+      TMP_DB_REDIS_DATABASE_INDEX,
+      TMP_DB_MONGODB_COLLECTION,
+      TMP_DB_SQL_TABLE,
+      TMP_EXCEPTION_TYPE,
+      TMP_EXCEPTION_MESSAGE,
+      TMP_EXCEPTION_STACKTRACE,
+      TMP_EXCEPTION_ESCAPED,
+      TMP_FAAS_TRIGGER,
+      TMP_FAAS_EXECUTION,
+      TMP_FAAS_DOCUMENT_COLLECTION,
+      TMP_FAAS_DOCUMENT_OPERATION,
+      TMP_FAAS_DOCUMENT_TIME,
+      TMP_FAAS_DOCUMENT_NAME,
+      TMP_FAAS_TIME,
+      TMP_FAAS_CRON,
+      TMP_FAAS_COLDSTART,
+      TMP_FAAS_INVOKED_NAME,
+      TMP_FAAS_INVOKED_PROVIDER,
+      TMP_FAAS_INVOKED_REGION,
+      TMP_NET_TRANSPORT,
+      TMP_NET_PEER_IP,
+      TMP_NET_PEER_PORT,
+      TMP_NET_PEER_NAME,
+      TMP_NET_HOST_IP,
+      TMP_NET_HOST_PORT,
+      TMP_NET_HOST_NAME,
+      TMP_NET_HOST_CONNECTION_TYPE,
+      TMP_NET_HOST_CONNECTION_SUBTYPE,
+      TMP_NET_HOST_CARRIER_NAME,
+      TMP_NET_HOST_CARRIER_MCC,
+      TMP_NET_HOST_CARRIER_MNC,
+      TMP_NET_HOST_CARRIER_ICC,
+      TMP_PEER_SERVICE,
+      TMP_ENDUSER_ID,
+      TMP_ENDUSER_ROLE,
+      TMP_ENDUSER_SCOPE,
+      TMP_THREAD_ID,
+      TMP_THREAD_NAME,
+      TMP_CODE_FUNCTION,
+      TMP_CODE_NAMESPACE,
+      TMP_CODE_FILEPATH,
+      TMP_CODE_LINENO,
+      TMP_HTTP_METHOD,
+      TMP_HTTP_URL,
+      TMP_HTTP_TARGET,
+      TMP_HTTP_HOST,
+      TMP_HTTP_SCHEME,
+      TMP_HTTP_STATUS_CODE,
+      TMP_HTTP_FLAVOR,
+      TMP_HTTP_USER_AGENT,
+      TMP_HTTP_REQUEST_CONTENT_LENGTH,
+      TMP_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED,
+      TMP_HTTP_RESPONSE_CONTENT_LENGTH,
+      TMP_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED,
+      TMP_HTTP_SERVER_NAME,
+      TMP_HTTP_ROUTE,
+      TMP_HTTP_CLIENT_IP,
+      TMP_AWS_DYNAMODB_TABLE_NAMES,
+      TMP_AWS_DYNAMODB_CONSUMED_CAPACITY,
+      TMP_AWS_DYNAMODB_ITEM_COLLECTION_METRICS,
+      TMP_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY,
+      TMP_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY,
+      TMP_AWS_DYNAMODB_CONSISTENT_READ,
+      TMP_AWS_DYNAMODB_PROJECTION,
+      TMP_AWS_DYNAMODB_LIMIT,
+      TMP_AWS_DYNAMODB_ATTRIBUTES_TO_GET,
+      TMP_AWS_DYNAMODB_INDEX_NAME,
+      TMP_AWS_DYNAMODB_SELECT,
+      TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES,
+      TMP_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES,
+      TMP_AWS_DYNAMODB_EXCLUSIVE_START_TABLE,
+      TMP_AWS_DYNAMODB_TABLE_COUNT,
+      TMP_AWS_DYNAMODB_SCAN_FORWARD,
+      TMP_AWS_DYNAMODB_SEGMENT,
+      TMP_AWS_DYNAMODB_TOTAL_SEGMENTS,
+      TMP_AWS_DYNAMODB_COUNT,
+      TMP_AWS_DYNAMODB_SCANNED_COUNT,
+      TMP_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS,
+      TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES,
+      TMP_MESSAGING_SYSTEM,
+      TMP_MESSAGING_DESTINATION,
+      TMP_MESSAGING_DESTINATION_KIND,
+      TMP_MESSAGING_TEMP_DESTINATION,
+      TMP_MESSAGING_PROTOCOL,
+      TMP_MESSAGING_PROTOCOL_VERSION,
+      TMP_MESSAGING_URL,
+      TMP_MESSAGING_MESSAGE_ID,
+      TMP_MESSAGING_CONVERSATION_ID,
+      TMP_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES,
+      TMP_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES,
+      TMP_MESSAGING_OPERATION,
+      TMP_MESSAGING_CONSUMER_ID,
+      TMP_MESSAGING_RABBITMQ_ROUTING_KEY,
+      TMP_MESSAGING_KAFKA_MESSAGE_KEY,
+      TMP_MESSAGING_KAFKA_CONSUMER_GROUP,
+      TMP_MESSAGING_KAFKA_CLIENT_ID,
+      TMP_MESSAGING_KAFKA_PARTITION,
+      TMP_MESSAGING_KAFKA_TOMBSTONE,
+      TMP_RPC_SYSTEM,
+      TMP_RPC_SERVICE,
+      TMP_RPC_METHOD,
+      TMP_RPC_GRPC_STATUS_CODE,
+      TMP_RPC_JSONRPC_VERSION,
+      TMP_RPC_JSONRPC_REQUEST_ID,
+      TMP_RPC_JSONRPC_ERROR_CODE,
+      TMP_RPC_JSONRPC_ERROR_MESSAGE,
+      TMP_MESSAGE_TYPE,
+      TMP_MESSAGE_ID,
+      TMP_MESSAGE_COMPRESSED_SIZE,
+      TMP_MESSAGE_UNCOMPRESSED_SIZE
+    ]);
+    TMP_DBSYSTEMVALUES_OTHER_SQL = "other_sql";
+    TMP_DBSYSTEMVALUES_MSSQL = "mssql";
+    TMP_DBSYSTEMVALUES_MYSQL = "mysql";
+    TMP_DBSYSTEMVALUES_ORACLE = "oracle";
+    TMP_DBSYSTEMVALUES_DB2 = "db2";
+    TMP_DBSYSTEMVALUES_POSTGRESQL = "postgresql";
+    TMP_DBSYSTEMVALUES_REDSHIFT = "redshift";
+    TMP_DBSYSTEMVALUES_HIVE = "hive";
+    TMP_DBSYSTEMVALUES_CLOUDSCAPE = "cloudscape";
+    TMP_DBSYSTEMVALUES_HSQLDB = "hsqldb";
+    TMP_DBSYSTEMVALUES_PROGRESS = "progress";
+    TMP_DBSYSTEMVALUES_MAXDB = "maxdb";
+    TMP_DBSYSTEMVALUES_HANADB = "hanadb";
+    TMP_DBSYSTEMVALUES_INGRES = "ingres";
+    TMP_DBSYSTEMVALUES_FIRSTSQL = "firstsql";
+    TMP_DBSYSTEMVALUES_EDB = "edb";
+    TMP_DBSYSTEMVALUES_CACHE = "cache";
+    TMP_DBSYSTEMVALUES_ADABAS = "adabas";
+    TMP_DBSYSTEMVALUES_FIREBIRD = "firebird";
+    TMP_DBSYSTEMVALUES_DERBY = "derby";
+    TMP_DBSYSTEMVALUES_FILEMAKER = "filemaker";
+    TMP_DBSYSTEMVALUES_INFORMIX = "informix";
+    TMP_DBSYSTEMVALUES_INSTANTDB = "instantdb";
+    TMP_DBSYSTEMVALUES_INTERBASE = "interbase";
+    TMP_DBSYSTEMVALUES_MARIADB = "mariadb";
+    TMP_DBSYSTEMVALUES_NETEZZA = "netezza";
+    TMP_DBSYSTEMVALUES_PERVASIVE = "pervasive";
+    TMP_DBSYSTEMVALUES_POINTBASE = "pointbase";
+    TMP_DBSYSTEMVALUES_SQLITE = "sqlite";
+    TMP_DBSYSTEMVALUES_SYBASE = "sybase";
+    TMP_DBSYSTEMVALUES_TERADATA = "teradata";
+    TMP_DBSYSTEMVALUES_VERTICA = "vertica";
+    TMP_DBSYSTEMVALUES_H2 = "h2";
+    TMP_DBSYSTEMVALUES_COLDFUSION = "coldfusion";
+    TMP_DBSYSTEMVALUES_CASSANDRA = "cassandra";
+    TMP_DBSYSTEMVALUES_HBASE = "hbase";
+    TMP_DBSYSTEMVALUES_MONGODB = "mongodb";
+    TMP_DBSYSTEMVALUES_REDIS = "redis";
+    TMP_DBSYSTEMVALUES_COUCHBASE = "couchbase";
+    TMP_DBSYSTEMVALUES_COUCHDB = "couchdb";
+    TMP_DBSYSTEMVALUES_COSMOSDB = "cosmosdb";
+    TMP_DBSYSTEMVALUES_DYNAMODB = "dynamodb";
+    TMP_DBSYSTEMVALUES_NEO4J = "neo4j";
+    TMP_DBSYSTEMVALUES_GEODE = "geode";
+    TMP_DBSYSTEMVALUES_ELASTICSEARCH = "elasticsearch";
+    TMP_DBSYSTEMVALUES_MEMCACHED = "memcached";
+    TMP_DBSYSTEMVALUES_COCKROACHDB = "cockroachdb";
+    DBSYSTEMVALUES_OTHER_SQL = TMP_DBSYSTEMVALUES_OTHER_SQL;
+    DBSYSTEMVALUES_MSSQL = TMP_DBSYSTEMVALUES_MSSQL;
+    DBSYSTEMVALUES_MYSQL = TMP_DBSYSTEMVALUES_MYSQL;
+    DBSYSTEMVALUES_ORACLE = TMP_DBSYSTEMVALUES_ORACLE;
+    DBSYSTEMVALUES_DB2 = TMP_DBSYSTEMVALUES_DB2;
+    DBSYSTEMVALUES_POSTGRESQL = TMP_DBSYSTEMVALUES_POSTGRESQL;
+    DBSYSTEMVALUES_REDSHIFT = TMP_DBSYSTEMVALUES_REDSHIFT;
+    DBSYSTEMVALUES_HIVE = TMP_DBSYSTEMVALUES_HIVE;
+    DBSYSTEMVALUES_CLOUDSCAPE = TMP_DBSYSTEMVALUES_CLOUDSCAPE;
+    DBSYSTEMVALUES_HSQLDB = TMP_DBSYSTEMVALUES_HSQLDB;
+    DBSYSTEMVALUES_PROGRESS = TMP_DBSYSTEMVALUES_PROGRESS;
+    DBSYSTEMVALUES_MAXDB = TMP_DBSYSTEMVALUES_MAXDB;
+    DBSYSTEMVALUES_HANADB = TMP_DBSYSTEMVALUES_HANADB;
+    DBSYSTEMVALUES_INGRES = TMP_DBSYSTEMVALUES_INGRES;
+    DBSYSTEMVALUES_FIRSTSQL = TMP_DBSYSTEMVALUES_FIRSTSQL;
+    DBSYSTEMVALUES_EDB = TMP_DBSYSTEMVALUES_EDB;
+    DBSYSTEMVALUES_CACHE = TMP_DBSYSTEMVALUES_CACHE;
+    DBSYSTEMVALUES_ADABAS = TMP_DBSYSTEMVALUES_ADABAS;
+    DBSYSTEMVALUES_FIREBIRD = TMP_DBSYSTEMVALUES_FIREBIRD;
+    DBSYSTEMVALUES_DERBY = TMP_DBSYSTEMVALUES_DERBY;
+    DBSYSTEMVALUES_FILEMAKER = TMP_DBSYSTEMVALUES_FILEMAKER;
+    DBSYSTEMVALUES_INFORMIX = TMP_DBSYSTEMVALUES_INFORMIX;
+    DBSYSTEMVALUES_INSTANTDB = TMP_DBSYSTEMVALUES_INSTANTDB;
+    DBSYSTEMVALUES_INTERBASE = TMP_DBSYSTEMVALUES_INTERBASE;
+    DBSYSTEMVALUES_MARIADB = TMP_DBSYSTEMVALUES_MARIADB;
+    DBSYSTEMVALUES_NETEZZA = TMP_DBSYSTEMVALUES_NETEZZA;
+    DBSYSTEMVALUES_PERVASIVE = TMP_DBSYSTEMVALUES_PERVASIVE;
+    DBSYSTEMVALUES_POINTBASE = TMP_DBSYSTEMVALUES_POINTBASE;
+    DBSYSTEMVALUES_SQLITE = TMP_DBSYSTEMVALUES_SQLITE;
+    DBSYSTEMVALUES_SYBASE = TMP_DBSYSTEMVALUES_SYBASE;
+    DBSYSTEMVALUES_TERADATA = TMP_DBSYSTEMVALUES_TERADATA;
+    DBSYSTEMVALUES_VERTICA = TMP_DBSYSTEMVALUES_VERTICA;
+    DBSYSTEMVALUES_H2 = TMP_DBSYSTEMVALUES_H2;
+    DBSYSTEMVALUES_COLDFUSION = TMP_DBSYSTEMVALUES_COLDFUSION;
+    DBSYSTEMVALUES_CASSANDRA = TMP_DBSYSTEMVALUES_CASSANDRA;
+    DBSYSTEMVALUES_HBASE = TMP_DBSYSTEMVALUES_HBASE;
+    DBSYSTEMVALUES_MONGODB = TMP_DBSYSTEMVALUES_MONGODB;
+    DBSYSTEMVALUES_REDIS = TMP_DBSYSTEMVALUES_REDIS;
+    DBSYSTEMVALUES_COUCHBASE = TMP_DBSYSTEMVALUES_COUCHBASE;
+    DBSYSTEMVALUES_COUCHDB = TMP_DBSYSTEMVALUES_COUCHDB;
+    DBSYSTEMVALUES_COSMOSDB = TMP_DBSYSTEMVALUES_COSMOSDB;
+    DBSYSTEMVALUES_DYNAMODB = TMP_DBSYSTEMVALUES_DYNAMODB;
+    DBSYSTEMVALUES_NEO4J = TMP_DBSYSTEMVALUES_NEO4J;
+    DBSYSTEMVALUES_GEODE = TMP_DBSYSTEMVALUES_GEODE;
+    DBSYSTEMVALUES_ELASTICSEARCH = TMP_DBSYSTEMVALUES_ELASTICSEARCH;
+    DBSYSTEMVALUES_MEMCACHED = TMP_DBSYSTEMVALUES_MEMCACHED;
+    DBSYSTEMVALUES_COCKROACHDB = TMP_DBSYSTEMVALUES_COCKROACHDB;
+    DbSystemValues = /* @__PURE__ */ createConstMap([
+      TMP_DBSYSTEMVALUES_OTHER_SQL,
+      TMP_DBSYSTEMVALUES_MSSQL,
+      TMP_DBSYSTEMVALUES_MYSQL,
+      TMP_DBSYSTEMVALUES_ORACLE,
+      TMP_DBSYSTEMVALUES_DB2,
+      TMP_DBSYSTEMVALUES_POSTGRESQL,
+      TMP_DBSYSTEMVALUES_REDSHIFT,
+      TMP_DBSYSTEMVALUES_HIVE,
+      TMP_DBSYSTEMVALUES_CLOUDSCAPE,
+      TMP_DBSYSTEMVALUES_HSQLDB,
+      TMP_DBSYSTEMVALUES_PROGRESS,
+      TMP_DBSYSTEMVALUES_MAXDB,
+      TMP_DBSYSTEMVALUES_HANADB,
+      TMP_DBSYSTEMVALUES_INGRES,
+      TMP_DBSYSTEMVALUES_FIRSTSQL,
+      TMP_DBSYSTEMVALUES_EDB,
+      TMP_DBSYSTEMVALUES_CACHE,
+      TMP_DBSYSTEMVALUES_ADABAS,
+      TMP_DBSYSTEMVALUES_FIREBIRD,
+      TMP_DBSYSTEMVALUES_DERBY,
+      TMP_DBSYSTEMVALUES_FILEMAKER,
+      TMP_DBSYSTEMVALUES_INFORMIX,
+      TMP_DBSYSTEMVALUES_INSTANTDB,
+      TMP_DBSYSTEMVALUES_INTERBASE,
+      TMP_DBSYSTEMVALUES_MARIADB,
+      TMP_DBSYSTEMVALUES_NETEZZA,
+      TMP_DBSYSTEMVALUES_PERVASIVE,
+      TMP_DBSYSTEMVALUES_POINTBASE,
+      TMP_DBSYSTEMVALUES_SQLITE,
+      TMP_DBSYSTEMVALUES_SYBASE,
+      TMP_DBSYSTEMVALUES_TERADATA,
+      TMP_DBSYSTEMVALUES_VERTICA,
+      TMP_DBSYSTEMVALUES_H2,
+      TMP_DBSYSTEMVALUES_COLDFUSION,
+      TMP_DBSYSTEMVALUES_CASSANDRA,
+      TMP_DBSYSTEMVALUES_HBASE,
+      TMP_DBSYSTEMVALUES_MONGODB,
+      TMP_DBSYSTEMVALUES_REDIS,
+      TMP_DBSYSTEMVALUES_COUCHBASE,
+      TMP_DBSYSTEMVALUES_COUCHDB,
+      TMP_DBSYSTEMVALUES_COSMOSDB,
+      TMP_DBSYSTEMVALUES_DYNAMODB,
+      TMP_DBSYSTEMVALUES_NEO4J,
+      TMP_DBSYSTEMVALUES_GEODE,
+      TMP_DBSYSTEMVALUES_ELASTICSEARCH,
+      TMP_DBSYSTEMVALUES_MEMCACHED,
+      TMP_DBSYSTEMVALUES_COCKROACHDB
+    ]);
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ALL = "all";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM = "each_quorum";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM = "quorum";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM = "local_quorum";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ONE = "one";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_TWO = "two";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_THREE = "three";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE = "local_one";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ANY = "any";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL = "serial";
+    TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL = "local_serial";
+    DBCASSANDRACONSISTENCYLEVELVALUES_ALL = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ALL;
+    DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM;
+    DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM;
+    DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM;
+    DBCASSANDRACONSISTENCYLEVELVALUES_ONE = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ONE;
+    DBCASSANDRACONSISTENCYLEVELVALUES_TWO = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_TWO;
+    DBCASSANDRACONSISTENCYLEVELVALUES_THREE = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_THREE;
+    DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE;
+    DBCASSANDRACONSISTENCYLEVELVALUES_ANY = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ANY;
+    DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL;
+    DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL;
+    DbCassandraConsistencyLevelValues = /* @__PURE__ */ createConstMap([
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ALL,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ONE,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_TWO,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_THREE,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ANY,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL,
+      TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL
+    ]);
+    TMP_FAASTRIGGERVALUES_DATASOURCE = "datasource";
+    TMP_FAASTRIGGERVALUES_HTTP = "http";
+    TMP_FAASTRIGGERVALUES_PUBSUB = "pubsub";
+    TMP_FAASTRIGGERVALUES_TIMER = "timer";
+    TMP_FAASTRIGGERVALUES_OTHER = "other";
+    FAASTRIGGERVALUES_DATASOURCE = TMP_FAASTRIGGERVALUES_DATASOURCE;
+    FAASTRIGGERVALUES_HTTP = TMP_FAASTRIGGERVALUES_HTTP;
+    FAASTRIGGERVALUES_PUBSUB = TMP_FAASTRIGGERVALUES_PUBSUB;
+    FAASTRIGGERVALUES_TIMER = TMP_FAASTRIGGERVALUES_TIMER;
+    FAASTRIGGERVALUES_OTHER = TMP_FAASTRIGGERVALUES_OTHER;
+    FaasTriggerValues = /* @__PURE__ */ createConstMap([
+      TMP_FAASTRIGGERVALUES_DATASOURCE,
+      TMP_FAASTRIGGERVALUES_HTTP,
+      TMP_FAASTRIGGERVALUES_PUBSUB,
+      TMP_FAASTRIGGERVALUES_TIMER,
+      TMP_FAASTRIGGERVALUES_OTHER
+    ]);
+    TMP_FAASDOCUMENTOPERATIONVALUES_INSERT = "insert";
+    TMP_FAASDOCUMENTOPERATIONVALUES_EDIT = "edit";
+    TMP_FAASDOCUMENTOPERATIONVALUES_DELETE = "delete";
+    FAASDOCUMENTOPERATIONVALUES_INSERT = TMP_FAASDOCUMENTOPERATIONVALUES_INSERT;
+    FAASDOCUMENTOPERATIONVALUES_EDIT = TMP_FAASDOCUMENTOPERATIONVALUES_EDIT;
+    FAASDOCUMENTOPERATIONVALUES_DELETE = TMP_FAASDOCUMENTOPERATIONVALUES_DELETE;
+    FaasDocumentOperationValues = /* @__PURE__ */ createConstMap([
+      TMP_FAASDOCUMENTOPERATIONVALUES_INSERT,
+      TMP_FAASDOCUMENTOPERATIONVALUES_EDIT,
+      TMP_FAASDOCUMENTOPERATIONVALUES_DELETE
+    ]);
+    TMP_FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD = "alibaba_cloud";
+    TMP_FAASINVOKEDPROVIDERVALUES_AWS = "aws";
+    TMP_FAASINVOKEDPROVIDERVALUES_AZURE = "azure";
+    TMP_FAASINVOKEDPROVIDERVALUES_GCP = "gcp";
+    FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD = TMP_FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD;
+    FAASINVOKEDPROVIDERVALUES_AWS = TMP_FAASINVOKEDPROVIDERVALUES_AWS;
+    FAASINVOKEDPROVIDERVALUES_AZURE = TMP_FAASINVOKEDPROVIDERVALUES_AZURE;
+    FAASINVOKEDPROVIDERVALUES_GCP = TMP_FAASINVOKEDPROVIDERVALUES_GCP;
+    FaasInvokedProviderValues = /* @__PURE__ */ createConstMap([
+      TMP_FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD,
+      TMP_FAASINVOKEDPROVIDERVALUES_AWS,
+      TMP_FAASINVOKEDPROVIDERVALUES_AZURE,
+      TMP_FAASINVOKEDPROVIDERVALUES_GCP
+    ]);
+    TMP_NETTRANSPORTVALUES_IP_TCP = "ip_tcp";
+    TMP_NETTRANSPORTVALUES_IP_UDP = "ip_udp";
+    TMP_NETTRANSPORTVALUES_IP = "ip";
+    TMP_NETTRANSPORTVALUES_UNIX = "unix";
+    TMP_NETTRANSPORTVALUES_PIPE = "pipe";
+    TMP_NETTRANSPORTVALUES_INPROC = "inproc";
+    TMP_NETTRANSPORTVALUES_OTHER = "other";
+    NETTRANSPORTVALUES_IP_TCP = TMP_NETTRANSPORTVALUES_IP_TCP;
+    NETTRANSPORTVALUES_IP_UDP = TMP_NETTRANSPORTVALUES_IP_UDP;
+    NETTRANSPORTVALUES_IP = TMP_NETTRANSPORTVALUES_IP;
+    NETTRANSPORTVALUES_UNIX = TMP_NETTRANSPORTVALUES_UNIX;
+    NETTRANSPORTVALUES_PIPE = TMP_NETTRANSPORTVALUES_PIPE;
+    NETTRANSPORTVALUES_INPROC = TMP_NETTRANSPORTVALUES_INPROC;
+    NETTRANSPORTVALUES_OTHER = TMP_NETTRANSPORTVALUES_OTHER;
+    NetTransportValues = /* @__PURE__ */ createConstMap([
+      TMP_NETTRANSPORTVALUES_IP_TCP,
+      TMP_NETTRANSPORTVALUES_IP_UDP,
+      TMP_NETTRANSPORTVALUES_IP,
+      TMP_NETTRANSPORTVALUES_UNIX,
+      TMP_NETTRANSPORTVALUES_PIPE,
+      TMP_NETTRANSPORTVALUES_INPROC,
+      TMP_NETTRANSPORTVALUES_OTHER
+    ]);
+    TMP_NETHOSTCONNECTIONTYPEVALUES_WIFI = "wifi";
+    TMP_NETHOSTCONNECTIONTYPEVALUES_WIRED = "wired";
+    TMP_NETHOSTCONNECTIONTYPEVALUES_CELL = "cell";
+    TMP_NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE = "unavailable";
+    TMP_NETHOSTCONNECTIONTYPEVALUES_UNKNOWN = "unknown";
+    NETHOSTCONNECTIONTYPEVALUES_WIFI = TMP_NETHOSTCONNECTIONTYPEVALUES_WIFI;
+    NETHOSTCONNECTIONTYPEVALUES_WIRED = TMP_NETHOSTCONNECTIONTYPEVALUES_WIRED;
+    NETHOSTCONNECTIONTYPEVALUES_CELL = TMP_NETHOSTCONNECTIONTYPEVALUES_CELL;
+    NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE = TMP_NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE;
+    NETHOSTCONNECTIONTYPEVALUES_UNKNOWN = TMP_NETHOSTCONNECTIONTYPEVALUES_UNKNOWN;
+    NetHostConnectionTypeValues = /* @__PURE__ */ createConstMap([
+      TMP_NETHOSTCONNECTIONTYPEVALUES_WIFI,
+      TMP_NETHOSTCONNECTIONTYPEVALUES_WIRED,
+      TMP_NETHOSTCONNECTIONTYPEVALUES_CELL,
+      TMP_NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE,
+      TMP_NETHOSTCONNECTIONTYPEVALUES_UNKNOWN
+    ]);
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GPRS = "gprs";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EDGE = "edge";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_UMTS = "umts";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA = "cdma";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0 = "evdo_0";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A = "evdo_a";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT = "cdma2000_1xrtt";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA = "hsdpa";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA = "hsupa";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPA = "hspa";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IDEN = "iden";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B = "evdo_b";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE = "lte";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD = "ehrpd";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP = "hspap";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GSM = "gsm";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA = "td_scdma";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN = "iwlan";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NR = "nr";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA = "nrnsa";
+    TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA = "lte_ca";
+    NETHOSTCONNECTIONSUBTYPEVALUES_GPRS = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GPRS;
+    NETHOSTCONNECTIONSUBTYPEVALUES_EDGE = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EDGE;
+    NETHOSTCONNECTIONSUBTYPEVALUES_UMTS = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_UMTS;
+    NETHOSTCONNECTIONSUBTYPEVALUES_CDMA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA;
+    NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0 = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0;
+    NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A;
+    NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT;
+    NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA;
+    NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA;
+    NETHOSTCONNECTIONSUBTYPEVALUES_HSPA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPA;
+    NETHOSTCONNECTIONSUBTYPEVALUES_IDEN = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IDEN;
+    NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B;
+    NETHOSTCONNECTIONSUBTYPEVALUES_LTE = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE;
+    NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD;
+    NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP;
+    NETHOSTCONNECTIONSUBTYPEVALUES_GSM = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GSM;
+    NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA;
+    NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN;
+    NETHOSTCONNECTIONSUBTYPEVALUES_NR = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NR;
+    NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA;
+    NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA;
+    NetHostConnectionSubtypeValues = /* @__PURE__ */ createConstMap([
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GPRS,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EDGE,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_UMTS,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPA,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IDEN,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GSM,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NR,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA,
+      TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA
+    ]);
+    TMP_HTTPFLAVORVALUES_HTTP_1_0 = "1.0";
+    TMP_HTTPFLAVORVALUES_HTTP_1_1 = "1.1";
+    TMP_HTTPFLAVORVALUES_HTTP_2_0 = "2.0";
+    TMP_HTTPFLAVORVALUES_SPDY = "SPDY";
+    TMP_HTTPFLAVORVALUES_QUIC = "QUIC";
+    HTTPFLAVORVALUES_HTTP_1_0 = TMP_HTTPFLAVORVALUES_HTTP_1_0;
+    HTTPFLAVORVALUES_HTTP_1_1 = TMP_HTTPFLAVORVALUES_HTTP_1_1;
+    HTTPFLAVORVALUES_HTTP_2_0 = TMP_HTTPFLAVORVALUES_HTTP_2_0;
+    HTTPFLAVORVALUES_SPDY = TMP_HTTPFLAVORVALUES_SPDY;
+    HTTPFLAVORVALUES_QUIC = TMP_HTTPFLAVORVALUES_QUIC;
+    HttpFlavorValues = {
+      HTTP_1_0: TMP_HTTPFLAVORVALUES_HTTP_1_0,
+      HTTP_1_1: TMP_HTTPFLAVORVALUES_HTTP_1_1,
+      HTTP_2_0: TMP_HTTPFLAVORVALUES_HTTP_2_0,
+      SPDY: TMP_HTTPFLAVORVALUES_SPDY,
+      QUIC: TMP_HTTPFLAVORVALUES_QUIC
+    };
+    TMP_MESSAGINGDESTINATIONKINDVALUES_QUEUE = "queue";
+    TMP_MESSAGINGDESTINATIONKINDVALUES_TOPIC = "topic";
+    MESSAGINGDESTINATIONKINDVALUES_QUEUE = TMP_MESSAGINGDESTINATIONKINDVALUES_QUEUE;
+    MESSAGINGDESTINATIONKINDVALUES_TOPIC = TMP_MESSAGINGDESTINATIONKINDVALUES_TOPIC;
+    MessagingDestinationKindValues = /* @__PURE__ */ createConstMap([
+      TMP_MESSAGINGDESTINATIONKINDVALUES_QUEUE,
+      TMP_MESSAGINGDESTINATIONKINDVALUES_TOPIC
+    ]);
+    TMP_MESSAGINGOPERATIONVALUES_RECEIVE = "receive";
+    TMP_MESSAGINGOPERATIONVALUES_PROCESS = "process";
+    MESSAGINGOPERATIONVALUES_RECEIVE = TMP_MESSAGINGOPERATIONVALUES_RECEIVE;
+    MESSAGINGOPERATIONVALUES_PROCESS = TMP_MESSAGINGOPERATIONVALUES_PROCESS;
+    MessagingOperationValues = /* @__PURE__ */ createConstMap([
+      TMP_MESSAGINGOPERATIONVALUES_RECEIVE,
+      TMP_MESSAGINGOPERATIONVALUES_PROCESS
+    ]);
+    TMP_RPCGRPCSTATUSCODEVALUES_OK = 0;
+    TMP_RPCGRPCSTATUSCODEVALUES_CANCELLED = 1;
+    TMP_RPCGRPCSTATUSCODEVALUES_UNKNOWN = 2;
+    TMP_RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT = 3;
+    TMP_RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED = 4;
+    TMP_RPCGRPCSTATUSCODEVALUES_NOT_FOUND = 5;
+    TMP_RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS = 6;
+    TMP_RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED = 7;
+    TMP_RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED = 8;
+    TMP_RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION = 9;
+    TMP_RPCGRPCSTATUSCODEVALUES_ABORTED = 10;
+    TMP_RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE = 11;
+    TMP_RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED = 12;
+    TMP_RPCGRPCSTATUSCODEVALUES_INTERNAL = 13;
+    TMP_RPCGRPCSTATUSCODEVALUES_UNAVAILABLE = 14;
+    TMP_RPCGRPCSTATUSCODEVALUES_DATA_LOSS = 15;
+    TMP_RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED = 16;
+    RPCGRPCSTATUSCODEVALUES_OK = TMP_RPCGRPCSTATUSCODEVALUES_OK;
+    RPCGRPCSTATUSCODEVALUES_CANCELLED = TMP_RPCGRPCSTATUSCODEVALUES_CANCELLED;
+    RPCGRPCSTATUSCODEVALUES_UNKNOWN = TMP_RPCGRPCSTATUSCODEVALUES_UNKNOWN;
+    RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT = TMP_RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT;
+    RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED = TMP_RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED;
+    RPCGRPCSTATUSCODEVALUES_NOT_FOUND = TMP_RPCGRPCSTATUSCODEVALUES_NOT_FOUND;
+    RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS = TMP_RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS;
+    RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED = TMP_RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED;
+    RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED = TMP_RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED;
+    RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION = TMP_RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION;
+    RPCGRPCSTATUSCODEVALUES_ABORTED = TMP_RPCGRPCSTATUSCODEVALUES_ABORTED;
+    RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE = TMP_RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE;
+    RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED = TMP_RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED;
+    RPCGRPCSTATUSCODEVALUES_INTERNAL = TMP_RPCGRPCSTATUSCODEVALUES_INTERNAL;
+    RPCGRPCSTATUSCODEVALUES_UNAVAILABLE = TMP_RPCGRPCSTATUSCODEVALUES_UNAVAILABLE;
+    RPCGRPCSTATUSCODEVALUES_DATA_LOSS = TMP_RPCGRPCSTATUSCODEVALUES_DATA_LOSS;
+    RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED = TMP_RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED;
+    RpcGrpcStatusCodeValues = {
+      OK: TMP_RPCGRPCSTATUSCODEVALUES_OK,
+      CANCELLED: TMP_RPCGRPCSTATUSCODEVALUES_CANCELLED,
+      UNKNOWN: TMP_RPCGRPCSTATUSCODEVALUES_UNKNOWN,
+      INVALID_ARGUMENT: TMP_RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT,
+      DEADLINE_EXCEEDED: TMP_RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED,
+      NOT_FOUND: TMP_RPCGRPCSTATUSCODEVALUES_NOT_FOUND,
+      ALREADY_EXISTS: TMP_RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS,
+      PERMISSION_DENIED: TMP_RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED,
+      RESOURCE_EXHAUSTED: TMP_RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED,
+      FAILED_PRECONDITION: TMP_RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION,
+      ABORTED: TMP_RPCGRPCSTATUSCODEVALUES_ABORTED,
+      OUT_OF_RANGE: TMP_RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE,
+      UNIMPLEMENTED: TMP_RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED,
+      INTERNAL: TMP_RPCGRPCSTATUSCODEVALUES_INTERNAL,
+      UNAVAILABLE: TMP_RPCGRPCSTATUSCODEVALUES_UNAVAILABLE,
+      DATA_LOSS: TMP_RPCGRPCSTATUSCODEVALUES_DATA_LOSS,
+      UNAUTHENTICATED: TMP_RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED
+    };
+    TMP_MESSAGETYPEVALUES_SENT = "SENT";
+    TMP_MESSAGETYPEVALUES_RECEIVED = "RECEIVED";
+    MESSAGETYPEVALUES_SENT = TMP_MESSAGETYPEVALUES_SENT;
+    MESSAGETYPEVALUES_RECEIVED = TMP_MESSAGETYPEVALUES_RECEIVED;
+    MessageTypeValues = /* @__PURE__ */ createConstMap([
+      TMP_MESSAGETYPEVALUES_SENT,
+      TMP_MESSAGETYPEVALUES_RECEIVED
+    ]);
+  }
+});
+
+// ../../node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js
+var init_trace2 = __esm({
+  "../../node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_SemanticAttributes();
+  }
+});
+
+// ../../node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js
+var TMP_CLOUD_PROVIDER, TMP_CLOUD_ACCOUNT_ID, TMP_CLOUD_REGION, TMP_CLOUD_AVAILABILITY_ZONE, TMP_CLOUD_PLATFORM, TMP_AWS_ECS_CONTAINER_ARN, TMP_AWS_ECS_CLUSTER_ARN, TMP_AWS_ECS_LAUNCHTYPE, TMP_AWS_ECS_TASK_ARN, TMP_AWS_ECS_TASK_FAMILY, TMP_AWS_ECS_TASK_REVISION, TMP_AWS_EKS_CLUSTER_ARN, TMP_AWS_LOG_GROUP_NAMES, TMP_AWS_LOG_GROUP_ARNS, TMP_AWS_LOG_STREAM_NAMES, TMP_AWS_LOG_STREAM_ARNS, TMP_CONTAINER_NAME, TMP_CONTAINER_ID, TMP_CONTAINER_RUNTIME, TMP_CONTAINER_IMAGE_NAME, TMP_CONTAINER_IMAGE_TAG, TMP_DEPLOYMENT_ENVIRONMENT, TMP_DEVICE_ID, TMP_DEVICE_MODEL_IDENTIFIER, TMP_DEVICE_MODEL_NAME, TMP_FAAS_NAME, TMP_FAAS_ID, TMP_FAAS_VERSION, TMP_FAAS_INSTANCE, TMP_FAAS_MAX_MEMORY, TMP_HOST_ID, TMP_HOST_NAME, TMP_HOST_TYPE, TMP_HOST_ARCH, TMP_HOST_IMAGE_NAME, TMP_HOST_IMAGE_ID, TMP_HOST_IMAGE_VERSION, TMP_K8S_CLUSTER_NAME, TMP_K8S_NODE_NAME, TMP_K8S_NODE_UID, TMP_K8S_NAMESPACE_NAME, TMP_K8S_POD_UID, TMP_K8S_POD_NAME, TMP_K8S_CONTAINER_NAME, TMP_K8S_REPLICASET_UID, TMP_K8S_REPLICASET_NAME, TMP_K8S_DEPLOYMENT_UID, TMP_K8S_DEPLOYMENT_NAME, TMP_K8S_STATEFULSET_UID, TMP_K8S_STATEFULSET_NAME, TMP_K8S_DAEMONSET_UID, TMP_K8S_DAEMONSET_NAME, TMP_K8S_JOB_UID, TMP_K8S_JOB_NAME, TMP_K8S_CRONJOB_UID, TMP_K8S_CRONJOB_NAME, TMP_OS_TYPE, TMP_OS_DESCRIPTION, TMP_OS_NAME, TMP_OS_VERSION, TMP_PROCESS_PID, TMP_PROCESS_EXECUTABLE_NAME, TMP_PROCESS_EXECUTABLE_PATH, TMP_PROCESS_COMMAND, TMP_PROCESS_COMMAND_LINE, TMP_PROCESS_COMMAND_ARGS, TMP_PROCESS_OWNER, TMP_PROCESS_RUNTIME_NAME, TMP_PROCESS_RUNTIME_VERSION, TMP_PROCESS_RUNTIME_DESCRIPTION, TMP_SERVICE_NAME, TMP_SERVICE_NAMESPACE, TMP_SERVICE_INSTANCE_ID, TMP_SERVICE_VERSION, TMP_TELEMETRY_SDK_NAME, TMP_TELEMETRY_SDK_LANGUAGE, TMP_TELEMETRY_SDK_VERSION, TMP_TELEMETRY_AUTO_VERSION, TMP_WEBENGINE_NAME, TMP_WEBENGINE_VERSION, TMP_WEBENGINE_DESCRIPTION, SEMRESATTRS_CLOUD_PROVIDER, SEMRESATTRS_CLOUD_ACCOUNT_ID, SEMRESATTRS_CLOUD_REGION, SEMRESATTRS_CLOUD_AVAILABILITY_ZONE, SEMRESATTRS_CLOUD_PLATFORM, SEMRESATTRS_AWS_ECS_CONTAINER_ARN, SEMRESATTRS_AWS_ECS_CLUSTER_ARN, SEMRESATTRS_AWS_ECS_LAUNCHTYPE, SEMRESATTRS_AWS_ECS_TASK_ARN, SEMRESATTRS_AWS_ECS_TASK_FAMILY, SEMRESATTRS_AWS_ECS_TASK_REVISION, SEMRESATTRS_AWS_EKS_CLUSTER_ARN, SEMRESATTRS_AWS_LOG_GROUP_NAMES, SEMRESATTRS_AWS_LOG_GROUP_ARNS, SEMRESATTRS_AWS_LOG_STREAM_NAMES, SEMRESATTRS_AWS_LOG_STREAM_ARNS, SEMRESATTRS_CONTAINER_NAME, SEMRESATTRS_CONTAINER_ID, SEMRESATTRS_CONTAINER_RUNTIME, SEMRESATTRS_CONTAINER_IMAGE_NAME, SEMRESATTRS_CONTAINER_IMAGE_TAG, SEMRESATTRS_DEPLOYMENT_ENVIRONMENT, SEMRESATTRS_DEVICE_ID, SEMRESATTRS_DEVICE_MODEL_IDENTIFIER, SEMRESATTRS_DEVICE_MODEL_NAME, SEMRESATTRS_FAAS_NAME, SEMRESATTRS_FAAS_ID, SEMRESATTRS_FAAS_VERSION, SEMRESATTRS_FAAS_INSTANCE, SEMRESATTRS_FAAS_MAX_MEMORY, SEMRESATTRS_HOST_ID, SEMRESATTRS_HOST_NAME, SEMRESATTRS_HOST_TYPE, SEMRESATTRS_HOST_ARCH, SEMRESATTRS_HOST_IMAGE_NAME, SEMRESATTRS_HOST_IMAGE_ID, SEMRESATTRS_HOST_IMAGE_VERSION, SEMRESATTRS_K8S_CLUSTER_NAME, SEMRESATTRS_K8S_NODE_NAME, SEMRESATTRS_K8S_NODE_UID, SEMRESATTRS_K8S_NAMESPACE_NAME, SEMRESATTRS_K8S_POD_UID, SEMRESATTRS_K8S_POD_NAME, SEMRESATTRS_K8S_CONTAINER_NAME, SEMRESATTRS_K8S_REPLICASET_UID, SEMRESATTRS_K8S_REPLICASET_NAME, SEMRESATTRS_K8S_DEPLOYMENT_UID, SEMRESATTRS_K8S_DEPLOYMENT_NAME, SEMRESATTRS_K8S_STATEFULSET_UID, SEMRESATTRS_K8S_STATEFULSET_NAME, SEMRESATTRS_K8S_DAEMONSET_UID, SEMRESATTRS_K8S_DAEMONSET_NAME, SEMRESATTRS_K8S_JOB_UID, SEMRESATTRS_K8S_JOB_NAME, SEMRESATTRS_K8S_CRONJOB_UID, SEMRESATTRS_K8S_CRONJOB_NAME, SEMRESATTRS_OS_TYPE, SEMRESATTRS_OS_DESCRIPTION, SEMRESATTRS_OS_NAME, SEMRESATTRS_OS_VERSION, SEMRESATTRS_PROCESS_PID, SEMRESATTRS_PROCESS_EXECUTABLE_NAME, SEMRESATTRS_PROCESS_EXECUTABLE_PATH, SEMRESATTRS_PROCESS_COMMAND, SEMRESATTRS_PROCESS_COMMAND_LINE, SEMRESATTRS_PROCESS_COMMAND_ARGS, SEMRESATTRS_PROCESS_OWNER, SEMRESATTRS_PROCESS_RUNTIME_NAME, SEMRESATTRS_PROCESS_RUNTIME_VERSION, SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION, SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_NAMESPACE, SEMRESATTRS_SERVICE_INSTANCE_ID, SEMRESATTRS_SERVICE_VERSION, SEMRESATTRS_TELEMETRY_SDK_NAME, SEMRESATTRS_TELEMETRY_SDK_LANGUAGE, SEMRESATTRS_TELEMETRY_SDK_VERSION, SEMRESATTRS_TELEMETRY_AUTO_VERSION, SEMRESATTRS_WEBENGINE_NAME, SEMRESATTRS_WEBENGINE_VERSION, SEMRESATTRS_WEBENGINE_DESCRIPTION, SemanticResourceAttributes, TMP_CLOUDPROVIDERVALUES_ALIBABA_CLOUD, TMP_CLOUDPROVIDERVALUES_AWS, TMP_CLOUDPROVIDERVALUES_AZURE, TMP_CLOUDPROVIDERVALUES_GCP, CLOUDPROVIDERVALUES_ALIBABA_CLOUD, CLOUDPROVIDERVALUES_AWS, CLOUDPROVIDERVALUES_AZURE, CLOUDPROVIDERVALUES_GCP, CloudProviderValues, TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS, TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC, TMP_CLOUDPLATFORMVALUES_AWS_EC2, TMP_CLOUDPLATFORMVALUES_AWS_ECS, TMP_CLOUDPLATFORMVALUES_AWS_EKS, TMP_CLOUDPLATFORMVALUES_AWS_LAMBDA, TMP_CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK, TMP_CLOUDPLATFORMVALUES_AZURE_VM, TMP_CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES, TMP_CLOUDPLATFORMVALUES_AZURE_AKS, TMP_CLOUDPLATFORMVALUES_AZURE_FUNCTIONS, TMP_CLOUDPLATFORMVALUES_AZURE_APP_SERVICE, TMP_CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE, TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_RUN, TMP_CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE, TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS, TMP_CLOUDPLATFORMVALUES_GCP_APP_ENGINE, CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS, CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC, CLOUDPLATFORMVALUES_AWS_EC2, CLOUDPLATFORMVALUES_AWS_ECS, CLOUDPLATFORMVALUES_AWS_EKS, CLOUDPLATFORMVALUES_AWS_LAMBDA, CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK, CLOUDPLATFORMVALUES_AZURE_VM, CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES, CLOUDPLATFORMVALUES_AZURE_AKS, CLOUDPLATFORMVALUES_AZURE_FUNCTIONS, CLOUDPLATFORMVALUES_AZURE_APP_SERVICE, CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE, CLOUDPLATFORMVALUES_GCP_CLOUD_RUN, CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE, CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS, CLOUDPLATFORMVALUES_GCP_APP_ENGINE, CloudPlatformValues, TMP_AWSECSLAUNCHTYPEVALUES_EC2, TMP_AWSECSLAUNCHTYPEVALUES_FARGATE, AWSECSLAUNCHTYPEVALUES_EC2, AWSECSLAUNCHTYPEVALUES_FARGATE, AwsEcsLaunchtypeValues, TMP_HOSTARCHVALUES_AMD64, TMP_HOSTARCHVALUES_ARM32, TMP_HOSTARCHVALUES_ARM64, TMP_HOSTARCHVALUES_IA64, TMP_HOSTARCHVALUES_PPC32, TMP_HOSTARCHVALUES_PPC64, TMP_HOSTARCHVALUES_X86, HOSTARCHVALUES_AMD64, HOSTARCHVALUES_ARM32, HOSTARCHVALUES_ARM64, HOSTARCHVALUES_IA64, HOSTARCHVALUES_PPC32, HOSTARCHVALUES_PPC64, HOSTARCHVALUES_X86, HostArchValues, TMP_OSTYPEVALUES_WINDOWS, TMP_OSTYPEVALUES_LINUX, TMP_OSTYPEVALUES_DARWIN, TMP_OSTYPEVALUES_FREEBSD, TMP_OSTYPEVALUES_NETBSD, TMP_OSTYPEVALUES_OPENBSD, TMP_OSTYPEVALUES_DRAGONFLYBSD, TMP_OSTYPEVALUES_HPUX, TMP_OSTYPEVALUES_AIX, TMP_OSTYPEVALUES_SOLARIS, TMP_OSTYPEVALUES_Z_OS, OSTYPEVALUES_WINDOWS, OSTYPEVALUES_LINUX, OSTYPEVALUES_DARWIN, OSTYPEVALUES_FREEBSD, OSTYPEVALUES_NETBSD, OSTYPEVALUES_OPENBSD, OSTYPEVALUES_DRAGONFLYBSD, OSTYPEVALUES_HPUX, OSTYPEVALUES_AIX, OSTYPEVALUES_SOLARIS, OSTYPEVALUES_Z_OS, OsTypeValues, TMP_TELEMETRYSDKLANGUAGEVALUES_CPP, TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET, TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG, TMP_TELEMETRYSDKLANGUAGEVALUES_GO, TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA, TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS, TMP_TELEMETRYSDKLANGUAGEVALUES_PHP, TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON, TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY, TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS, TELEMETRYSDKLANGUAGEVALUES_CPP, TELEMETRYSDKLANGUAGEVALUES_DOTNET, TELEMETRYSDKLANGUAGEVALUES_ERLANG, TELEMETRYSDKLANGUAGEVALUES_GO, TELEMETRYSDKLANGUAGEVALUES_JAVA, TELEMETRYSDKLANGUAGEVALUES_NODEJS, TELEMETRYSDKLANGUAGEVALUES_PHP, TELEMETRYSDKLANGUAGEVALUES_PYTHON, TELEMETRYSDKLANGUAGEVALUES_RUBY, TELEMETRYSDKLANGUAGEVALUES_WEBJS, TelemetrySdkLanguageValues;
+var init_SemanticResourceAttributes = __esm({
+  "../../node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js"() {
+    "use strict";
+    init_esm_shims();
+    init_utils3();
+    TMP_CLOUD_PROVIDER = "cloud.provider";
+    TMP_CLOUD_ACCOUNT_ID = "cloud.account.id";
+    TMP_CLOUD_REGION = "cloud.region";
+    TMP_CLOUD_AVAILABILITY_ZONE = "cloud.availability_zone";
+    TMP_CLOUD_PLATFORM = "cloud.platform";
+    TMP_AWS_ECS_CONTAINER_ARN = "aws.ecs.container.arn";
+    TMP_AWS_ECS_CLUSTER_ARN = "aws.ecs.cluster.arn";
+    TMP_AWS_ECS_LAUNCHTYPE = "aws.ecs.launchtype";
+    TMP_AWS_ECS_TASK_ARN = "aws.ecs.task.arn";
+    TMP_AWS_ECS_TASK_FAMILY = "aws.ecs.task.family";
+    TMP_AWS_ECS_TASK_REVISION = "aws.ecs.task.revision";
+    TMP_AWS_EKS_CLUSTER_ARN = "aws.eks.cluster.arn";
+    TMP_AWS_LOG_GROUP_NAMES = "aws.log.group.names";
+    TMP_AWS_LOG_GROUP_ARNS = "aws.log.group.arns";
+    TMP_AWS_LOG_STREAM_NAMES = "aws.log.stream.names";
+    TMP_AWS_LOG_STREAM_ARNS = "aws.log.stream.arns";
+    TMP_CONTAINER_NAME = "container.name";
+    TMP_CONTAINER_ID = "container.id";
+    TMP_CONTAINER_RUNTIME = "container.runtime";
+    TMP_CONTAINER_IMAGE_NAME = "container.image.name";
+    TMP_CONTAINER_IMAGE_TAG = "container.image.tag";
+    TMP_DEPLOYMENT_ENVIRONMENT = "deployment.environment";
+    TMP_DEVICE_ID = "device.id";
+    TMP_DEVICE_MODEL_IDENTIFIER = "device.model.identifier";
+    TMP_DEVICE_MODEL_NAME = "device.model.name";
+    TMP_FAAS_NAME = "faas.name";
+    TMP_FAAS_ID = "faas.id";
+    TMP_FAAS_VERSION = "faas.version";
+    TMP_FAAS_INSTANCE = "faas.instance";
+    TMP_FAAS_MAX_MEMORY = "faas.max_memory";
+    TMP_HOST_ID = "host.id";
+    TMP_HOST_NAME = "host.name";
+    TMP_HOST_TYPE = "host.type";
+    TMP_HOST_ARCH = "host.arch";
+    TMP_HOST_IMAGE_NAME = "host.image.name";
+    TMP_HOST_IMAGE_ID = "host.image.id";
+    TMP_HOST_IMAGE_VERSION = "host.image.version";
+    TMP_K8S_CLUSTER_NAME = "k8s.cluster.name";
+    TMP_K8S_NODE_NAME = "k8s.node.name";
+    TMP_K8S_NODE_UID = "k8s.node.uid";
+    TMP_K8S_NAMESPACE_NAME = "k8s.namespace.name";
+    TMP_K8S_POD_UID = "k8s.pod.uid";
+    TMP_K8S_POD_NAME = "k8s.pod.name";
+    TMP_K8S_CONTAINER_NAME = "k8s.container.name";
+    TMP_K8S_REPLICASET_UID = "k8s.replicaset.uid";
+    TMP_K8S_REPLICASET_NAME = "k8s.replicaset.name";
+    TMP_K8S_DEPLOYMENT_UID = "k8s.deployment.uid";
+    TMP_K8S_DEPLOYMENT_NAME = "k8s.deployment.name";
+    TMP_K8S_STATEFULSET_UID = "k8s.statefulset.uid";
+    TMP_K8S_STATEFULSET_NAME = "k8s.statefulset.name";
+    TMP_K8S_DAEMONSET_UID = "k8s.daemonset.uid";
+    TMP_K8S_DAEMONSET_NAME = "k8s.daemonset.name";
+    TMP_K8S_JOB_UID = "k8s.job.uid";
+    TMP_K8S_JOB_NAME = "k8s.job.name";
+    TMP_K8S_CRONJOB_UID = "k8s.cronjob.uid";
+    TMP_K8S_CRONJOB_NAME = "k8s.cronjob.name";
+    TMP_OS_TYPE = "os.type";
+    TMP_OS_DESCRIPTION = "os.description";
+    TMP_OS_NAME = "os.name";
+    TMP_OS_VERSION = "os.version";
+    TMP_PROCESS_PID = "process.pid";
+    TMP_PROCESS_EXECUTABLE_NAME = "process.executable.name";
+    TMP_PROCESS_EXECUTABLE_PATH = "process.executable.path";
+    TMP_PROCESS_COMMAND = "process.command";
+    TMP_PROCESS_COMMAND_LINE = "process.command_line";
+    TMP_PROCESS_COMMAND_ARGS = "process.command_args";
+    TMP_PROCESS_OWNER = "process.owner";
+    TMP_PROCESS_RUNTIME_NAME = "process.runtime.name";
+    TMP_PROCESS_RUNTIME_VERSION = "process.runtime.version";
+    TMP_PROCESS_RUNTIME_DESCRIPTION = "process.runtime.description";
+    TMP_SERVICE_NAME = "service.name";
+    TMP_SERVICE_NAMESPACE = "service.namespace";
+    TMP_SERVICE_INSTANCE_ID = "service.instance.id";
+    TMP_SERVICE_VERSION = "service.version";
+    TMP_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
+    TMP_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
+    TMP_TELEMETRY_SDK_VERSION = "telemetry.sdk.version";
+    TMP_TELEMETRY_AUTO_VERSION = "telemetry.auto.version";
+    TMP_WEBENGINE_NAME = "webengine.name";
+    TMP_WEBENGINE_VERSION = "webengine.version";
+    TMP_WEBENGINE_DESCRIPTION = "webengine.description";
+    SEMRESATTRS_CLOUD_PROVIDER = TMP_CLOUD_PROVIDER;
+    SEMRESATTRS_CLOUD_ACCOUNT_ID = TMP_CLOUD_ACCOUNT_ID;
+    SEMRESATTRS_CLOUD_REGION = TMP_CLOUD_REGION;
+    SEMRESATTRS_CLOUD_AVAILABILITY_ZONE = TMP_CLOUD_AVAILABILITY_ZONE;
+    SEMRESATTRS_CLOUD_PLATFORM = TMP_CLOUD_PLATFORM;
+    SEMRESATTRS_AWS_ECS_CONTAINER_ARN = TMP_AWS_ECS_CONTAINER_ARN;
+    SEMRESATTRS_AWS_ECS_CLUSTER_ARN = TMP_AWS_ECS_CLUSTER_ARN;
+    SEMRESATTRS_AWS_ECS_LAUNCHTYPE = TMP_AWS_ECS_LAUNCHTYPE;
+    SEMRESATTRS_AWS_ECS_TASK_ARN = TMP_AWS_ECS_TASK_ARN;
+    SEMRESATTRS_AWS_ECS_TASK_FAMILY = TMP_AWS_ECS_TASK_FAMILY;
+    SEMRESATTRS_AWS_ECS_TASK_REVISION = TMP_AWS_ECS_TASK_REVISION;
+    SEMRESATTRS_AWS_EKS_CLUSTER_ARN = TMP_AWS_EKS_CLUSTER_ARN;
+    SEMRESATTRS_AWS_LOG_GROUP_NAMES = TMP_AWS_LOG_GROUP_NAMES;
+    SEMRESATTRS_AWS_LOG_GROUP_ARNS = TMP_AWS_LOG_GROUP_ARNS;
+    SEMRESATTRS_AWS_LOG_STREAM_NAMES = TMP_AWS_LOG_STREAM_NAMES;
+    SEMRESATTRS_AWS_LOG_STREAM_ARNS = TMP_AWS_LOG_STREAM_ARNS;
+    SEMRESATTRS_CONTAINER_NAME = TMP_CONTAINER_NAME;
+    SEMRESATTRS_CONTAINER_ID = TMP_CONTAINER_ID;
+    SEMRESATTRS_CONTAINER_RUNTIME = TMP_CONTAINER_RUNTIME;
+    SEMRESATTRS_CONTAINER_IMAGE_NAME = TMP_CONTAINER_IMAGE_NAME;
+    SEMRESATTRS_CONTAINER_IMAGE_TAG = TMP_CONTAINER_IMAGE_TAG;
+    SEMRESATTRS_DEPLOYMENT_ENVIRONMENT = TMP_DEPLOYMENT_ENVIRONMENT;
+    SEMRESATTRS_DEVICE_ID = TMP_DEVICE_ID;
+    SEMRESATTRS_DEVICE_MODEL_IDENTIFIER = TMP_DEVICE_MODEL_IDENTIFIER;
+    SEMRESATTRS_DEVICE_MODEL_NAME = TMP_DEVICE_MODEL_NAME;
+    SEMRESATTRS_FAAS_NAME = TMP_FAAS_NAME;
+    SEMRESATTRS_FAAS_ID = TMP_FAAS_ID;
+    SEMRESATTRS_FAAS_VERSION = TMP_FAAS_VERSION;
+    SEMRESATTRS_FAAS_INSTANCE = TMP_FAAS_INSTANCE;
+    SEMRESATTRS_FAAS_MAX_MEMORY = TMP_FAAS_MAX_MEMORY;
+    SEMRESATTRS_HOST_ID = TMP_HOST_ID;
+    SEMRESATTRS_HOST_NAME = TMP_HOST_NAME;
+    SEMRESATTRS_HOST_TYPE = TMP_HOST_TYPE;
+    SEMRESATTRS_HOST_ARCH = TMP_HOST_ARCH;
+    SEMRESATTRS_HOST_IMAGE_NAME = TMP_HOST_IMAGE_NAME;
+    SEMRESATTRS_HOST_IMAGE_ID = TMP_HOST_IMAGE_ID;
+    SEMRESATTRS_HOST_IMAGE_VERSION = TMP_HOST_IMAGE_VERSION;
+    SEMRESATTRS_K8S_CLUSTER_NAME = TMP_K8S_CLUSTER_NAME;
+    SEMRESATTRS_K8S_NODE_NAME = TMP_K8S_NODE_NAME;
+    SEMRESATTRS_K8S_NODE_UID = TMP_K8S_NODE_UID;
+    SEMRESATTRS_K8S_NAMESPACE_NAME = TMP_K8S_NAMESPACE_NAME;
+    SEMRESATTRS_K8S_POD_UID = TMP_K8S_POD_UID;
+    SEMRESATTRS_K8S_POD_NAME = TMP_K8S_POD_NAME;
+    SEMRESATTRS_K8S_CONTAINER_NAME = TMP_K8S_CONTAINER_NAME;
+    SEMRESATTRS_K8S_REPLICASET_UID = TMP_K8S_REPLICASET_UID;
+    SEMRESATTRS_K8S_REPLICASET_NAME = TMP_K8S_REPLICASET_NAME;
+    SEMRESATTRS_K8S_DEPLOYMENT_UID = TMP_K8S_DEPLOYMENT_UID;
+    SEMRESATTRS_K8S_DEPLOYMENT_NAME = TMP_K8S_DEPLOYMENT_NAME;
+    SEMRESATTRS_K8S_STATEFULSET_UID = TMP_K8S_STATEFULSET_UID;
+    SEMRESATTRS_K8S_STATEFULSET_NAME = TMP_K8S_STATEFULSET_NAME;
+    SEMRESATTRS_K8S_DAEMONSET_UID = TMP_K8S_DAEMONSET_UID;
+    SEMRESATTRS_K8S_DAEMONSET_NAME = TMP_K8S_DAEMONSET_NAME;
+    SEMRESATTRS_K8S_JOB_UID = TMP_K8S_JOB_UID;
+    SEMRESATTRS_K8S_JOB_NAME = TMP_K8S_JOB_NAME;
+    SEMRESATTRS_K8S_CRONJOB_UID = TMP_K8S_CRONJOB_UID;
+    SEMRESATTRS_K8S_CRONJOB_NAME = TMP_K8S_CRONJOB_NAME;
+    SEMRESATTRS_OS_TYPE = TMP_OS_TYPE;
+    SEMRESATTRS_OS_DESCRIPTION = TMP_OS_DESCRIPTION;
+    SEMRESATTRS_OS_NAME = TMP_OS_NAME;
+    SEMRESATTRS_OS_VERSION = TMP_OS_VERSION;
+    SEMRESATTRS_PROCESS_PID = TMP_PROCESS_PID;
+    SEMRESATTRS_PROCESS_EXECUTABLE_NAME = TMP_PROCESS_EXECUTABLE_NAME;
+    SEMRESATTRS_PROCESS_EXECUTABLE_PATH = TMP_PROCESS_EXECUTABLE_PATH;
+    SEMRESATTRS_PROCESS_COMMAND = TMP_PROCESS_COMMAND;
+    SEMRESATTRS_PROCESS_COMMAND_LINE = TMP_PROCESS_COMMAND_LINE;
+    SEMRESATTRS_PROCESS_COMMAND_ARGS = TMP_PROCESS_COMMAND_ARGS;
+    SEMRESATTRS_PROCESS_OWNER = TMP_PROCESS_OWNER;
+    SEMRESATTRS_PROCESS_RUNTIME_NAME = TMP_PROCESS_RUNTIME_NAME;
+    SEMRESATTRS_PROCESS_RUNTIME_VERSION = TMP_PROCESS_RUNTIME_VERSION;
+    SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION = TMP_PROCESS_RUNTIME_DESCRIPTION;
+    SEMRESATTRS_SERVICE_NAME = TMP_SERVICE_NAME;
+    SEMRESATTRS_SERVICE_NAMESPACE = TMP_SERVICE_NAMESPACE;
+    SEMRESATTRS_SERVICE_INSTANCE_ID = TMP_SERVICE_INSTANCE_ID;
+    SEMRESATTRS_SERVICE_VERSION = TMP_SERVICE_VERSION;
+    SEMRESATTRS_TELEMETRY_SDK_NAME = TMP_TELEMETRY_SDK_NAME;
+    SEMRESATTRS_TELEMETRY_SDK_LANGUAGE = TMP_TELEMETRY_SDK_LANGUAGE;
+    SEMRESATTRS_TELEMETRY_SDK_VERSION = TMP_TELEMETRY_SDK_VERSION;
+    SEMRESATTRS_TELEMETRY_AUTO_VERSION = TMP_TELEMETRY_AUTO_VERSION;
+    SEMRESATTRS_WEBENGINE_NAME = TMP_WEBENGINE_NAME;
+    SEMRESATTRS_WEBENGINE_VERSION = TMP_WEBENGINE_VERSION;
+    SEMRESATTRS_WEBENGINE_DESCRIPTION = TMP_WEBENGINE_DESCRIPTION;
+    SemanticResourceAttributes = /* @__PURE__ */ createConstMap([
+      TMP_CLOUD_PROVIDER,
+      TMP_CLOUD_ACCOUNT_ID,
+      TMP_CLOUD_REGION,
+      TMP_CLOUD_AVAILABILITY_ZONE,
+      TMP_CLOUD_PLATFORM,
+      TMP_AWS_ECS_CONTAINER_ARN,
+      TMP_AWS_ECS_CLUSTER_ARN,
+      TMP_AWS_ECS_LAUNCHTYPE,
+      TMP_AWS_ECS_TASK_ARN,
+      TMP_AWS_ECS_TASK_FAMILY,
+      TMP_AWS_ECS_TASK_REVISION,
+      TMP_AWS_EKS_CLUSTER_ARN,
+      TMP_AWS_LOG_GROUP_NAMES,
+      TMP_AWS_LOG_GROUP_ARNS,
+      TMP_AWS_LOG_STREAM_NAMES,
+      TMP_AWS_LOG_STREAM_ARNS,
+      TMP_CONTAINER_NAME,
+      TMP_CONTAINER_ID,
+      TMP_CONTAINER_RUNTIME,
+      TMP_CONTAINER_IMAGE_NAME,
+      TMP_CONTAINER_IMAGE_TAG,
+      TMP_DEPLOYMENT_ENVIRONMENT,
+      TMP_DEVICE_ID,
+      TMP_DEVICE_MODEL_IDENTIFIER,
+      TMP_DEVICE_MODEL_NAME,
+      TMP_FAAS_NAME,
+      TMP_FAAS_ID,
+      TMP_FAAS_VERSION,
+      TMP_FAAS_INSTANCE,
+      TMP_FAAS_MAX_MEMORY,
+      TMP_HOST_ID,
+      TMP_HOST_NAME,
+      TMP_HOST_TYPE,
+      TMP_HOST_ARCH,
+      TMP_HOST_IMAGE_NAME,
+      TMP_HOST_IMAGE_ID,
+      TMP_HOST_IMAGE_VERSION,
+      TMP_K8S_CLUSTER_NAME,
+      TMP_K8S_NODE_NAME,
+      TMP_K8S_NODE_UID,
+      TMP_K8S_NAMESPACE_NAME,
+      TMP_K8S_POD_UID,
+      TMP_K8S_POD_NAME,
+      TMP_K8S_CONTAINER_NAME,
+      TMP_K8S_REPLICASET_UID,
+      TMP_K8S_REPLICASET_NAME,
+      TMP_K8S_DEPLOYMENT_UID,
+      TMP_K8S_DEPLOYMENT_NAME,
+      TMP_K8S_STATEFULSET_UID,
+      TMP_K8S_STATEFULSET_NAME,
+      TMP_K8S_DAEMONSET_UID,
+      TMP_K8S_DAEMONSET_NAME,
+      TMP_K8S_JOB_UID,
+      TMP_K8S_JOB_NAME,
+      TMP_K8S_CRONJOB_UID,
+      TMP_K8S_CRONJOB_NAME,
+      TMP_OS_TYPE,
+      TMP_OS_DESCRIPTION,
+      TMP_OS_NAME,
+      TMP_OS_VERSION,
+      TMP_PROCESS_PID,
+      TMP_PROCESS_EXECUTABLE_NAME,
+      TMP_PROCESS_EXECUTABLE_PATH,
+      TMP_PROCESS_COMMAND,
+      TMP_PROCESS_COMMAND_LINE,
+      TMP_PROCESS_COMMAND_ARGS,
+      TMP_PROCESS_OWNER,
+      TMP_PROCESS_RUNTIME_NAME,
+      TMP_PROCESS_RUNTIME_VERSION,
+      TMP_PROCESS_RUNTIME_DESCRIPTION,
+      TMP_SERVICE_NAME,
+      TMP_SERVICE_NAMESPACE,
+      TMP_SERVICE_INSTANCE_ID,
+      TMP_SERVICE_VERSION,
+      TMP_TELEMETRY_SDK_NAME,
+      TMP_TELEMETRY_SDK_LANGUAGE,
+      TMP_TELEMETRY_SDK_VERSION,
+      TMP_TELEMETRY_AUTO_VERSION,
+      TMP_WEBENGINE_NAME,
+      TMP_WEBENGINE_VERSION,
+      TMP_WEBENGINE_DESCRIPTION
+    ]);
+    TMP_CLOUDPROVIDERVALUES_ALIBABA_CLOUD = "alibaba_cloud";
+    TMP_CLOUDPROVIDERVALUES_AWS = "aws";
+    TMP_CLOUDPROVIDERVALUES_AZURE = "azure";
+    TMP_CLOUDPROVIDERVALUES_GCP = "gcp";
+    CLOUDPROVIDERVALUES_ALIBABA_CLOUD = TMP_CLOUDPROVIDERVALUES_ALIBABA_CLOUD;
+    CLOUDPROVIDERVALUES_AWS = TMP_CLOUDPROVIDERVALUES_AWS;
+    CLOUDPROVIDERVALUES_AZURE = TMP_CLOUDPROVIDERVALUES_AZURE;
+    CLOUDPROVIDERVALUES_GCP = TMP_CLOUDPROVIDERVALUES_GCP;
+    CloudProviderValues = /* @__PURE__ */ createConstMap([
+      TMP_CLOUDPROVIDERVALUES_ALIBABA_CLOUD,
+      TMP_CLOUDPROVIDERVALUES_AWS,
+      TMP_CLOUDPROVIDERVALUES_AZURE,
+      TMP_CLOUDPROVIDERVALUES_GCP
+    ]);
+    TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS = "alibaba_cloud_ecs";
+    TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC = "alibaba_cloud_fc";
+    TMP_CLOUDPLATFORMVALUES_AWS_EC2 = "aws_ec2";
+    TMP_CLOUDPLATFORMVALUES_AWS_ECS = "aws_ecs";
+    TMP_CLOUDPLATFORMVALUES_AWS_EKS = "aws_eks";
+    TMP_CLOUDPLATFORMVALUES_AWS_LAMBDA = "aws_lambda";
+    TMP_CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK = "aws_elastic_beanstalk";
+    TMP_CLOUDPLATFORMVALUES_AZURE_VM = "azure_vm";
+    TMP_CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES = "azure_container_instances";
+    TMP_CLOUDPLATFORMVALUES_AZURE_AKS = "azure_aks";
+    TMP_CLOUDPLATFORMVALUES_AZURE_FUNCTIONS = "azure_functions";
+    TMP_CLOUDPLATFORMVALUES_AZURE_APP_SERVICE = "azure_app_service";
+    TMP_CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE = "gcp_compute_engine";
+    TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_RUN = "gcp_cloud_run";
+    TMP_CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE = "gcp_kubernetes_engine";
+    TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS = "gcp_cloud_functions";
+    TMP_CLOUDPLATFORMVALUES_GCP_APP_ENGINE = "gcp_app_engine";
+    CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS = TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS;
+    CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC = TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC;
+    CLOUDPLATFORMVALUES_AWS_EC2 = TMP_CLOUDPLATFORMVALUES_AWS_EC2;
+    CLOUDPLATFORMVALUES_AWS_ECS = TMP_CLOUDPLATFORMVALUES_AWS_ECS;
+    CLOUDPLATFORMVALUES_AWS_EKS = TMP_CLOUDPLATFORMVALUES_AWS_EKS;
+    CLOUDPLATFORMVALUES_AWS_LAMBDA = TMP_CLOUDPLATFORMVALUES_AWS_LAMBDA;
+    CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK = TMP_CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK;
+    CLOUDPLATFORMVALUES_AZURE_VM = TMP_CLOUDPLATFORMVALUES_AZURE_VM;
+    CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES = TMP_CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES;
+    CLOUDPLATFORMVALUES_AZURE_AKS = TMP_CLOUDPLATFORMVALUES_AZURE_AKS;
+    CLOUDPLATFORMVALUES_AZURE_FUNCTIONS = TMP_CLOUDPLATFORMVALUES_AZURE_FUNCTIONS;
+    CLOUDPLATFORMVALUES_AZURE_APP_SERVICE = TMP_CLOUDPLATFORMVALUES_AZURE_APP_SERVICE;
+    CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE = TMP_CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE;
+    CLOUDPLATFORMVALUES_GCP_CLOUD_RUN = TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_RUN;
+    CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE = TMP_CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE;
+    CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS = TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS;
+    CLOUDPLATFORMVALUES_GCP_APP_ENGINE = TMP_CLOUDPLATFORMVALUES_GCP_APP_ENGINE;
+    CloudPlatformValues = /* @__PURE__ */ createConstMap([
+      TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS,
+      TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC,
+      TMP_CLOUDPLATFORMVALUES_AWS_EC2,
+      TMP_CLOUDPLATFORMVALUES_AWS_ECS,
+      TMP_CLOUDPLATFORMVALUES_AWS_EKS,
+      TMP_CLOUDPLATFORMVALUES_AWS_LAMBDA,
+      TMP_CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK,
+      TMP_CLOUDPLATFORMVALUES_AZURE_VM,
+      TMP_CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES,
+      TMP_CLOUDPLATFORMVALUES_AZURE_AKS,
+      TMP_CLOUDPLATFORMVALUES_AZURE_FUNCTIONS,
+      TMP_CLOUDPLATFORMVALUES_AZURE_APP_SERVICE,
+      TMP_CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE,
+      TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_RUN,
+      TMP_CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE,
+      TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS,
+      TMP_CLOUDPLATFORMVALUES_GCP_APP_ENGINE
+    ]);
+    TMP_AWSECSLAUNCHTYPEVALUES_EC2 = "ec2";
+    TMP_AWSECSLAUNCHTYPEVALUES_FARGATE = "fargate";
+    AWSECSLAUNCHTYPEVALUES_EC2 = TMP_AWSECSLAUNCHTYPEVALUES_EC2;
+    AWSECSLAUNCHTYPEVALUES_FARGATE = TMP_AWSECSLAUNCHTYPEVALUES_FARGATE;
+    AwsEcsLaunchtypeValues = /* @__PURE__ */ createConstMap([
+      TMP_AWSECSLAUNCHTYPEVALUES_EC2,
+      TMP_AWSECSLAUNCHTYPEVALUES_FARGATE
+    ]);
+    TMP_HOSTARCHVALUES_AMD64 = "amd64";
+    TMP_HOSTARCHVALUES_ARM32 = "arm32";
+    TMP_HOSTARCHVALUES_ARM64 = "arm64";
+    TMP_HOSTARCHVALUES_IA64 = "ia64";
+    TMP_HOSTARCHVALUES_PPC32 = "ppc32";
+    TMP_HOSTARCHVALUES_PPC64 = "ppc64";
+    TMP_HOSTARCHVALUES_X86 = "x86";
+    HOSTARCHVALUES_AMD64 = TMP_HOSTARCHVALUES_AMD64;
+    HOSTARCHVALUES_ARM32 = TMP_HOSTARCHVALUES_ARM32;
+    HOSTARCHVALUES_ARM64 = TMP_HOSTARCHVALUES_ARM64;
+    HOSTARCHVALUES_IA64 = TMP_HOSTARCHVALUES_IA64;
+    HOSTARCHVALUES_PPC32 = TMP_HOSTARCHVALUES_PPC32;
+    HOSTARCHVALUES_PPC64 = TMP_HOSTARCHVALUES_PPC64;
+    HOSTARCHVALUES_X86 = TMP_HOSTARCHVALUES_X86;
+    HostArchValues = /* @__PURE__ */ createConstMap([
+      TMP_HOSTARCHVALUES_AMD64,
+      TMP_HOSTARCHVALUES_ARM32,
+      TMP_HOSTARCHVALUES_ARM64,
+      TMP_HOSTARCHVALUES_IA64,
+      TMP_HOSTARCHVALUES_PPC32,
+      TMP_HOSTARCHVALUES_PPC64,
+      TMP_HOSTARCHVALUES_X86
+    ]);
+    TMP_OSTYPEVALUES_WINDOWS = "windows";
+    TMP_OSTYPEVALUES_LINUX = "linux";
+    TMP_OSTYPEVALUES_DARWIN = "darwin";
+    TMP_OSTYPEVALUES_FREEBSD = "freebsd";
+    TMP_OSTYPEVALUES_NETBSD = "netbsd";
+    TMP_OSTYPEVALUES_OPENBSD = "openbsd";
+    TMP_OSTYPEVALUES_DRAGONFLYBSD = "dragonflybsd";
+    TMP_OSTYPEVALUES_HPUX = "hpux";
+    TMP_OSTYPEVALUES_AIX = "aix";
+    TMP_OSTYPEVALUES_SOLARIS = "solaris";
+    TMP_OSTYPEVALUES_Z_OS = "z_os";
+    OSTYPEVALUES_WINDOWS = TMP_OSTYPEVALUES_WINDOWS;
+    OSTYPEVALUES_LINUX = TMP_OSTYPEVALUES_LINUX;
+    OSTYPEVALUES_DARWIN = TMP_OSTYPEVALUES_DARWIN;
+    OSTYPEVALUES_FREEBSD = TMP_OSTYPEVALUES_FREEBSD;
+    OSTYPEVALUES_NETBSD = TMP_OSTYPEVALUES_NETBSD;
+    OSTYPEVALUES_OPENBSD = TMP_OSTYPEVALUES_OPENBSD;
+    OSTYPEVALUES_DRAGONFLYBSD = TMP_OSTYPEVALUES_DRAGONFLYBSD;
+    OSTYPEVALUES_HPUX = TMP_OSTYPEVALUES_HPUX;
+    OSTYPEVALUES_AIX = TMP_OSTYPEVALUES_AIX;
+    OSTYPEVALUES_SOLARIS = TMP_OSTYPEVALUES_SOLARIS;
+    OSTYPEVALUES_Z_OS = TMP_OSTYPEVALUES_Z_OS;
+    OsTypeValues = /* @__PURE__ */ createConstMap([
+      TMP_OSTYPEVALUES_WINDOWS,
+      TMP_OSTYPEVALUES_LINUX,
+      TMP_OSTYPEVALUES_DARWIN,
+      TMP_OSTYPEVALUES_FREEBSD,
+      TMP_OSTYPEVALUES_NETBSD,
+      TMP_OSTYPEVALUES_OPENBSD,
+      TMP_OSTYPEVALUES_DRAGONFLYBSD,
+      TMP_OSTYPEVALUES_HPUX,
+      TMP_OSTYPEVALUES_AIX,
+      TMP_OSTYPEVALUES_SOLARIS,
+      TMP_OSTYPEVALUES_Z_OS
+    ]);
+    TMP_TELEMETRYSDKLANGUAGEVALUES_CPP = "cpp";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET = "dotnet";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG = "erlang";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_GO = "go";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA = "java";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS = "nodejs";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_PHP = "php";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON = "python";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY = "ruby";
+    TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS = "webjs";
+    TELEMETRYSDKLANGUAGEVALUES_CPP = TMP_TELEMETRYSDKLANGUAGEVALUES_CPP;
+    TELEMETRYSDKLANGUAGEVALUES_DOTNET = TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET;
+    TELEMETRYSDKLANGUAGEVALUES_ERLANG = TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG;
+    TELEMETRYSDKLANGUAGEVALUES_GO = TMP_TELEMETRYSDKLANGUAGEVALUES_GO;
+    TELEMETRYSDKLANGUAGEVALUES_JAVA = TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA;
+    TELEMETRYSDKLANGUAGEVALUES_NODEJS = TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS;
+    TELEMETRYSDKLANGUAGEVALUES_PHP = TMP_TELEMETRYSDKLANGUAGEVALUES_PHP;
+    TELEMETRYSDKLANGUAGEVALUES_PYTHON = TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON;
+    TELEMETRYSDKLANGUAGEVALUES_RUBY = TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY;
+    TELEMETRYSDKLANGUAGEVALUES_WEBJS = TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS;
+    TelemetrySdkLanguageValues = /* @__PURE__ */ createConstMap([
+      TMP_TELEMETRYSDKLANGUAGEVALUES_CPP,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_GO,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_PHP,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY,
+      TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS
+    ]);
+  }
+});
+
+// ../../node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js
+var init_resource = __esm({
+  "../../node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_SemanticResourceAttributes();
+  }
+});
+
+// ../../node_modules/@opentelemetry/semantic-conventions/build/esm/index.js
+var esm_exports2 = {};
+__export(esm_exports2, {
+  AWSECSLAUNCHTYPEVALUES_EC2: () => AWSECSLAUNCHTYPEVALUES_EC2,
+  AWSECSLAUNCHTYPEVALUES_FARGATE: () => AWSECSLAUNCHTYPEVALUES_FARGATE,
+  AwsEcsLaunchtypeValues: () => AwsEcsLaunchtypeValues,
+  CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS: () => CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS,
+  CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC: () => CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC,
+  CLOUDPLATFORMVALUES_AWS_EC2: () => CLOUDPLATFORMVALUES_AWS_EC2,
+  CLOUDPLATFORMVALUES_AWS_ECS: () => CLOUDPLATFORMVALUES_AWS_ECS,
+  CLOUDPLATFORMVALUES_AWS_EKS: () => CLOUDPLATFORMVALUES_AWS_EKS,
+  CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK: () => CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK,
+  CLOUDPLATFORMVALUES_AWS_LAMBDA: () => CLOUDPLATFORMVALUES_AWS_LAMBDA,
+  CLOUDPLATFORMVALUES_AZURE_AKS: () => CLOUDPLATFORMVALUES_AZURE_AKS,
+  CLOUDPLATFORMVALUES_AZURE_APP_SERVICE: () => CLOUDPLATFORMVALUES_AZURE_APP_SERVICE,
+  CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES: () => CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES,
+  CLOUDPLATFORMVALUES_AZURE_FUNCTIONS: () => CLOUDPLATFORMVALUES_AZURE_FUNCTIONS,
+  CLOUDPLATFORMVALUES_AZURE_VM: () => CLOUDPLATFORMVALUES_AZURE_VM,
+  CLOUDPLATFORMVALUES_GCP_APP_ENGINE: () => CLOUDPLATFORMVALUES_GCP_APP_ENGINE,
+  CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS: () => CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS,
+  CLOUDPLATFORMVALUES_GCP_CLOUD_RUN: () => CLOUDPLATFORMVALUES_GCP_CLOUD_RUN,
+  CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE: () => CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE,
+  CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE: () => CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE,
+  CLOUDPROVIDERVALUES_ALIBABA_CLOUD: () => CLOUDPROVIDERVALUES_ALIBABA_CLOUD,
+  CLOUDPROVIDERVALUES_AWS: () => CLOUDPROVIDERVALUES_AWS,
+  CLOUDPROVIDERVALUES_AZURE: () => CLOUDPROVIDERVALUES_AZURE,
+  CLOUDPROVIDERVALUES_GCP: () => CLOUDPROVIDERVALUES_GCP,
+  CloudPlatformValues: () => CloudPlatformValues,
+  CloudProviderValues: () => CloudProviderValues,
+  DBCASSANDRACONSISTENCYLEVELVALUES_ALL: () => DBCASSANDRACONSISTENCYLEVELVALUES_ALL,
+  DBCASSANDRACONSISTENCYLEVELVALUES_ANY: () => DBCASSANDRACONSISTENCYLEVELVALUES_ANY,
+  DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM: () => DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM,
+  DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE: () => DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE,
+  DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM: () => DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM,
+  DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL: () => DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL,
+  DBCASSANDRACONSISTENCYLEVELVALUES_ONE: () => DBCASSANDRACONSISTENCYLEVELVALUES_ONE,
+  DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM: () => DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM,
+  DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL: () => DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL,
+  DBCASSANDRACONSISTENCYLEVELVALUES_THREE: () => DBCASSANDRACONSISTENCYLEVELVALUES_THREE,
+  DBCASSANDRACONSISTENCYLEVELVALUES_TWO: () => DBCASSANDRACONSISTENCYLEVELVALUES_TWO,
+  DBSYSTEMVALUES_ADABAS: () => DBSYSTEMVALUES_ADABAS,
+  DBSYSTEMVALUES_CACHE: () => DBSYSTEMVALUES_CACHE,
+  DBSYSTEMVALUES_CASSANDRA: () => DBSYSTEMVALUES_CASSANDRA,
+  DBSYSTEMVALUES_CLOUDSCAPE: () => DBSYSTEMVALUES_CLOUDSCAPE,
+  DBSYSTEMVALUES_COCKROACHDB: () => DBSYSTEMVALUES_COCKROACHDB,
+  DBSYSTEMVALUES_COLDFUSION: () => DBSYSTEMVALUES_COLDFUSION,
+  DBSYSTEMVALUES_COSMOSDB: () => DBSYSTEMVALUES_COSMOSDB,
+  DBSYSTEMVALUES_COUCHBASE: () => DBSYSTEMVALUES_COUCHBASE,
+  DBSYSTEMVALUES_COUCHDB: () => DBSYSTEMVALUES_COUCHDB,
+  DBSYSTEMVALUES_DB2: () => DBSYSTEMVALUES_DB2,
+  DBSYSTEMVALUES_DERBY: () => DBSYSTEMVALUES_DERBY,
+  DBSYSTEMVALUES_DYNAMODB: () => DBSYSTEMVALUES_DYNAMODB,
+  DBSYSTEMVALUES_EDB: () => DBSYSTEMVALUES_EDB,
+  DBSYSTEMVALUES_ELASTICSEARCH: () => DBSYSTEMVALUES_ELASTICSEARCH,
+  DBSYSTEMVALUES_FILEMAKER: () => DBSYSTEMVALUES_FILEMAKER,
+  DBSYSTEMVALUES_FIREBIRD: () => DBSYSTEMVALUES_FIREBIRD,
+  DBSYSTEMVALUES_FIRSTSQL: () => DBSYSTEMVALUES_FIRSTSQL,
+  DBSYSTEMVALUES_GEODE: () => DBSYSTEMVALUES_GEODE,
+  DBSYSTEMVALUES_H2: () => DBSYSTEMVALUES_H2,
+  DBSYSTEMVALUES_HANADB: () => DBSYSTEMVALUES_HANADB,
+  DBSYSTEMVALUES_HBASE: () => DBSYSTEMVALUES_HBASE,
+  DBSYSTEMVALUES_HIVE: () => DBSYSTEMVALUES_HIVE,
+  DBSYSTEMVALUES_HSQLDB: () => DBSYSTEMVALUES_HSQLDB,
+  DBSYSTEMVALUES_INFORMIX: () => DBSYSTEMVALUES_INFORMIX,
+  DBSYSTEMVALUES_INGRES: () => DBSYSTEMVALUES_INGRES,
+  DBSYSTEMVALUES_INSTANTDB: () => DBSYSTEMVALUES_INSTANTDB,
+  DBSYSTEMVALUES_INTERBASE: () => DBSYSTEMVALUES_INTERBASE,
+  DBSYSTEMVALUES_MARIADB: () => DBSYSTEMVALUES_MARIADB,
+  DBSYSTEMVALUES_MAXDB: () => DBSYSTEMVALUES_MAXDB,
+  DBSYSTEMVALUES_MEMCACHED: () => DBSYSTEMVALUES_MEMCACHED,
+  DBSYSTEMVALUES_MONGODB: () => DBSYSTEMVALUES_MONGODB,
+  DBSYSTEMVALUES_MSSQL: () => DBSYSTEMVALUES_MSSQL,
+  DBSYSTEMVALUES_MYSQL: () => DBSYSTEMVALUES_MYSQL,
+  DBSYSTEMVALUES_NEO4J: () => DBSYSTEMVALUES_NEO4J,
+  DBSYSTEMVALUES_NETEZZA: () => DBSYSTEMVALUES_NETEZZA,
+  DBSYSTEMVALUES_ORACLE: () => DBSYSTEMVALUES_ORACLE,
+  DBSYSTEMVALUES_OTHER_SQL: () => DBSYSTEMVALUES_OTHER_SQL,
+  DBSYSTEMVALUES_PERVASIVE: () => DBSYSTEMVALUES_PERVASIVE,
+  DBSYSTEMVALUES_POINTBASE: () => DBSYSTEMVALUES_POINTBASE,
+  DBSYSTEMVALUES_POSTGRESQL: () => DBSYSTEMVALUES_POSTGRESQL,
+  DBSYSTEMVALUES_PROGRESS: () => DBSYSTEMVALUES_PROGRESS,
+  DBSYSTEMVALUES_REDIS: () => DBSYSTEMVALUES_REDIS,
+  DBSYSTEMVALUES_REDSHIFT: () => DBSYSTEMVALUES_REDSHIFT,
+  DBSYSTEMVALUES_SQLITE: () => DBSYSTEMVALUES_SQLITE,
+  DBSYSTEMVALUES_SYBASE: () => DBSYSTEMVALUES_SYBASE,
+  DBSYSTEMVALUES_TERADATA: () => DBSYSTEMVALUES_TERADATA,
+  DBSYSTEMVALUES_VERTICA: () => DBSYSTEMVALUES_VERTICA,
+  DbCassandraConsistencyLevelValues: () => DbCassandraConsistencyLevelValues,
+  DbSystemValues: () => DbSystemValues,
+  FAASDOCUMENTOPERATIONVALUES_DELETE: () => FAASDOCUMENTOPERATIONVALUES_DELETE,
+  FAASDOCUMENTOPERATIONVALUES_EDIT: () => FAASDOCUMENTOPERATIONVALUES_EDIT,
+  FAASDOCUMENTOPERATIONVALUES_INSERT: () => FAASDOCUMENTOPERATIONVALUES_INSERT,
+  FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD: () => FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD,
+  FAASINVOKEDPROVIDERVALUES_AWS: () => FAASINVOKEDPROVIDERVALUES_AWS,
+  FAASINVOKEDPROVIDERVALUES_AZURE: () => FAASINVOKEDPROVIDERVALUES_AZURE,
+  FAASINVOKEDPROVIDERVALUES_GCP: () => FAASINVOKEDPROVIDERVALUES_GCP,
+  FAASTRIGGERVALUES_DATASOURCE: () => FAASTRIGGERVALUES_DATASOURCE,
+  FAASTRIGGERVALUES_HTTP: () => FAASTRIGGERVALUES_HTTP,
+  FAASTRIGGERVALUES_OTHER: () => FAASTRIGGERVALUES_OTHER,
+  FAASTRIGGERVALUES_PUBSUB: () => FAASTRIGGERVALUES_PUBSUB,
+  FAASTRIGGERVALUES_TIMER: () => FAASTRIGGERVALUES_TIMER,
+  FaasDocumentOperationValues: () => FaasDocumentOperationValues,
+  FaasInvokedProviderValues: () => FaasInvokedProviderValues,
+  FaasTriggerValues: () => FaasTriggerValues,
+  HOSTARCHVALUES_AMD64: () => HOSTARCHVALUES_AMD64,
+  HOSTARCHVALUES_ARM32: () => HOSTARCHVALUES_ARM32,
+  HOSTARCHVALUES_ARM64: () => HOSTARCHVALUES_ARM64,
+  HOSTARCHVALUES_IA64: () => HOSTARCHVALUES_IA64,
+  HOSTARCHVALUES_PPC32: () => HOSTARCHVALUES_PPC32,
+  HOSTARCHVALUES_PPC64: () => HOSTARCHVALUES_PPC64,
+  HOSTARCHVALUES_X86: () => HOSTARCHVALUES_X86,
+  HTTPFLAVORVALUES_HTTP_1_0: () => HTTPFLAVORVALUES_HTTP_1_0,
+  HTTPFLAVORVALUES_HTTP_1_1: () => HTTPFLAVORVALUES_HTTP_1_1,
+  HTTPFLAVORVALUES_HTTP_2_0: () => HTTPFLAVORVALUES_HTTP_2_0,
+  HTTPFLAVORVALUES_QUIC: () => HTTPFLAVORVALUES_QUIC,
+  HTTPFLAVORVALUES_SPDY: () => HTTPFLAVORVALUES_SPDY,
+  HostArchValues: () => HostArchValues,
+  HttpFlavorValues: () => HttpFlavorValues,
+  MESSAGETYPEVALUES_RECEIVED: () => MESSAGETYPEVALUES_RECEIVED,
+  MESSAGETYPEVALUES_SENT: () => MESSAGETYPEVALUES_SENT,
+  MESSAGINGDESTINATIONKINDVALUES_QUEUE: () => MESSAGINGDESTINATIONKINDVALUES_QUEUE,
+  MESSAGINGDESTINATIONKINDVALUES_TOPIC: () => MESSAGINGDESTINATIONKINDVALUES_TOPIC,
+  MESSAGINGOPERATIONVALUES_PROCESS: () => MESSAGINGOPERATIONVALUES_PROCESS,
+  MESSAGINGOPERATIONVALUES_RECEIVE: () => MESSAGINGOPERATIONVALUES_RECEIVE,
+  MessageTypeValues: () => MessageTypeValues,
+  MessagingDestinationKindValues: () => MessagingDestinationKindValues,
+  MessagingOperationValues: () => MessagingOperationValues,
+  NETHOSTCONNECTIONSUBTYPEVALUES_CDMA: () => NETHOSTCONNECTIONSUBTYPEVALUES_CDMA,
+  NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT: () => NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT,
+  NETHOSTCONNECTIONSUBTYPEVALUES_EDGE: () => NETHOSTCONNECTIONSUBTYPEVALUES_EDGE,
+  NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD: () => NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD,
+  NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0: () => NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0,
+  NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A: () => NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A,
+  NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B: () => NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B,
+  NETHOSTCONNECTIONSUBTYPEVALUES_GPRS: () => NETHOSTCONNECTIONSUBTYPEVALUES_GPRS,
+  NETHOSTCONNECTIONSUBTYPEVALUES_GSM: () => NETHOSTCONNECTIONSUBTYPEVALUES_GSM,
+  NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA: () => NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA,
+  NETHOSTCONNECTIONSUBTYPEVALUES_HSPA: () => NETHOSTCONNECTIONSUBTYPEVALUES_HSPA,
+  NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP: () => NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP,
+  NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA: () => NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA,
+  NETHOSTCONNECTIONSUBTYPEVALUES_IDEN: () => NETHOSTCONNECTIONSUBTYPEVALUES_IDEN,
+  NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN: () => NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN,
+  NETHOSTCONNECTIONSUBTYPEVALUES_LTE: () => NETHOSTCONNECTIONSUBTYPEVALUES_LTE,
+  NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA: () => NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA,
+  NETHOSTCONNECTIONSUBTYPEVALUES_NR: () => NETHOSTCONNECTIONSUBTYPEVALUES_NR,
+  NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA: () => NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA,
+  NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA: () => NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA,
+  NETHOSTCONNECTIONSUBTYPEVALUES_UMTS: () => NETHOSTCONNECTIONSUBTYPEVALUES_UMTS,
+  NETHOSTCONNECTIONTYPEVALUES_CELL: () => NETHOSTCONNECTIONTYPEVALUES_CELL,
+  NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE: () => NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE,
+  NETHOSTCONNECTIONTYPEVALUES_UNKNOWN: () => NETHOSTCONNECTIONTYPEVALUES_UNKNOWN,
+  NETHOSTCONNECTIONTYPEVALUES_WIFI: () => NETHOSTCONNECTIONTYPEVALUES_WIFI,
+  NETHOSTCONNECTIONTYPEVALUES_WIRED: () => NETHOSTCONNECTIONTYPEVALUES_WIRED,
+  NETTRANSPORTVALUES_INPROC: () => NETTRANSPORTVALUES_INPROC,
+  NETTRANSPORTVALUES_IP: () => NETTRANSPORTVALUES_IP,
+  NETTRANSPORTVALUES_IP_TCP: () => NETTRANSPORTVALUES_IP_TCP,
+  NETTRANSPORTVALUES_IP_UDP: () => NETTRANSPORTVALUES_IP_UDP,
+  NETTRANSPORTVALUES_OTHER: () => NETTRANSPORTVALUES_OTHER,
+  NETTRANSPORTVALUES_PIPE: () => NETTRANSPORTVALUES_PIPE,
+  NETTRANSPORTVALUES_UNIX: () => NETTRANSPORTVALUES_UNIX,
+  NetHostConnectionSubtypeValues: () => NetHostConnectionSubtypeValues,
+  NetHostConnectionTypeValues: () => NetHostConnectionTypeValues,
+  NetTransportValues: () => NetTransportValues,
+  OSTYPEVALUES_AIX: () => OSTYPEVALUES_AIX,
+  OSTYPEVALUES_DARWIN: () => OSTYPEVALUES_DARWIN,
+  OSTYPEVALUES_DRAGONFLYBSD: () => OSTYPEVALUES_DRAGONFLYBSD,
+  OSTYPEVALUES_FREEBSD: () => OSTYPEVALUES_FREEBSD,
+  OSTYPEVALUES_HPUX: () => OSTYPEVALUES_HPUX,
+  OSTYPEVALUES_LINUX: () => OSTYPEVALUES_LINUX,
+  OSTYPEVALUES_NETBSD: () => OSTYPEVALUES_NETBSD,
+  OSTYPEVALUES_OPENBSD: () => OSTYPEVALUES_OPENBSD,
+  OSTYPEVALUES_SOLARIS: () => OSTYPEVALUES_SOLARIS,
+  OSTYPEVALUES_WINDOWS: () => OSTYPEVALUES_WINDOWS,
+  OSTYPEVALUES_Z_OS: () => OSTYPEVALUES_Z_OS,
+  OsTypeValues: () => OsTypeValues,
+  RPCGRPCSTATUSCODEVALUES_ABORTED: () => RPCGRPCSTATUSCODEVALUES_ABORTED,
+  RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS: () => RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS,
+  RPCGRPCSTATUSCODEVALUES_CANCELLED: () => RPCGRPCSTATUSCODEVALUES_CANCELLED,
+  RPCGRPCSTATUSCODEVALUES_DATA_LOSS: () => RPCGRPCSTATUSCODEVALUES_DATA_LOSS,
+  RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED: () => RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED,
+  RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION: () => RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION,
+  RPCGRPCSTATUSCODEVALUES_INTERNAL: () => RPCGRPCSTATUSCODEVALUES_INTERNAL,
+  RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT: () => RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT,
+  RPCGRPCSTATUSCODEVALUES_NOT_FOUND: () => RPCGRPCSTATUSCODEVALUES_NOT_FOUND,
+  RPCGRPCSTATUSCODEVALUES_OK: () => RPCGRPCSTATUSCODEVALUES_OK,
+  RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE: () => RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE,
+  RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED: () => RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED,
+  RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED: () => RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED,
+  RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED: () => RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED,
+  RPCGRPCSTATUSCODEVALUES_UNAVAILABLE: () => RPCGRPCSTATUSCODEVALUES_UNAVAILABLE,
+  RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED: () => RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED,
+  RPCGRPCSTATUSCODEVALUES_UNKNOWN: () => RPCGRPCSTATUSCODEVALUES_UNKNOWN,
+  RpcGrpcStatusCodeValues: () => RpcGrpcStatusCodeValues,
+  SEMATTRS_AWS_DYNAMODB_ATTRIBUTES_TO_GET: () => SEMATTRS_AWS_DYNAMODB_ATTRIBUTES_TO_GET,
+  SEMATTRS_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS: () => SEMATTRS_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS,
+  SEMATTRS_AWS_DYNAMODB_CONSISTENT_READ: () => SEMATTRS_AWS_DYNAMODB_CONSISTENT_READ,
+  SEMATTRS_AWS_DYNAMODB_CONSUMED_CAPACITY: () => SEMATTRS_AWS_DYNAMODB_CONSUMED_CAPACITY,
+  SEMATTRS_AWS_DYNAMODB_COUNT: () => SEMATTRS_AWS_DYNAMODB_COUNT,
+  SEMATTRS_AWS_DYNAMODB_EXCLUSIVE_START_TABLE: () => SEMATTRS_AWS_DYNAMODB_EXCLUSIVE_START_TABLE,
+  SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES: () => SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES,
+  SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES: () => SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES,
+  SEMATTRS_AWS_DYNAMODB_INDEX_NAME: () => SEMATTRS_AWS_DYNAMODB_INDEX_NAME,
+  SEMATTRS_AWS_DYNAMODB_ITEM_COLLECTION_METRICS: () => SEMATTRS_AWS_DYNAMODB_ITEM_COLLECTION_METRICS,
+  SEMATTRS_AWS_DYNAMODB_LIMIT: () => SEMATTRS_AWS_DYNAMODB_LIMIT,
+  SEMATTRS_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES: () => SEMATTRS_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES,
+  SEMATTRS_AWS_DYNAMODB_PROJECTION: () => SEMATTRS_AWS_DYNAMODB_PROJECTION,
+  SEMATTRS_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY: () => SEMATTRS_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY,
+  SEMATTRS_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY: () => SEMATTRS_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY,
+  SEMATTRS_AWS_DYNAMODB_SCANNED_COUNT: () => SEMATTRS_AWS_DYNAMODB_SCANNED_COUNT,
+  SEMATTRS_AWS_DYNAMODB_SCAN_FORWARD: () => SEMATTRS_AWS_DYNAMODB_SCAN_FORWARD,
+  SEMATTRS_AWS_DYNAMODB_SEGMENT: () => SEMATTRS_AWS_DYNAMODB_SEGMENT,
+  SEMATTRS_AWS_DYNAMODB_SELECT: () => SEMATTRS_AWS_DYNAMODB_SELECT,
+  SEMATTRS_AWS_DYNAMODB_TABLE_COUNT: () => SEMATTRS_AWS_DYNAMODB_TABLE_COUNT,
+  SEMATTRS_AWS_DYNAMODB_TABLE_NAMES: () => SEMATTRS_AWS_DYNAMODB_TABLE_NAMES,
+  SEMATTRS_AWS_DYNAMODB_TOTAL_SEGMENTS: () => SEMATTRS_AWS_DYNAMODB_TOTAL_SEGMENTS,
+  SEMATTRS_AWS_LAMBDA_INVOKED_ARN: () => SEMATTRS_AWS_LAMBDA_INVOKED_ARN,
+  SEMATTRS_CODE_FILEPATH: () => SEMATTRS_CODE_FILEPATH,
+  SEMATTRS_CODE_FUNCTION: () => SEMATTRS_CODE_FUNCTION,
+  SEMATTRS_CODE_LINENO: () => SEMATTRS_CODE_LINENO,
+  SEMATTRS_CODE_NAMESPACE: () => SEMATTRS_CODE_NAMESPACE,
+  SEMATTRS_DB_CASSANDRA_CONSISTENCY_LEVEL: () => SEMATTRS_DB_CASSANDRA_CONSISTENCY_LEVEL,
+  SEMATTRS_DB_CASSANDRA_COORDINATOR_DC: () => SEMATTRS_DB_CASSANDRA_COORDINATOR_DC,
+  SEMATTRS_DB_CASSANDRA_COORDINATOR_ID: () => SEMATTRS_DB_CASSANDRA_COORDINATOR_ID,
+  SEMATTRS_DB_CASSANDRA_IDEMPOTENCE: () => SEMATTRS_DB_CASSANDRA_IDEMPOTENCE,
+  SEMATTRS_DB_CASSANDRA_KEYSPACE: () => SEMATTRS_DB_CASSANDRA_KEYSPACE,
+  SEMATTRS_DB_CASSANDRA_PAGE_SIZE: () => SEMATTRS_DB_CASSANDRA_PAGE_SIZE,
+  SEMATTRS_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT: () => SEMATTRS_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT,
+  SEMATTRS_DB_CASSANDRA_TABLE: () => SEMATTRS_DB_CASSANDRA_TABLE,
+  SEMATTRS_DB_CONNECTION_STRING: () => SEMATTRS_DB_CONNECTION_STRING,
+  SEMATTRS_DB_HBASE_NAMESPACE: () => SEMATTRS_DB_HBASE_NAMESPACE,
+  SEMATTRS_DB_JDBC_DRIVER_CLASSNAME: () => SEMATTRS_DB_JDBC_DRIVER_CLASSNAME,
+  SEMATTRS_DB_MONGODB_COLLECTION: () => SEMATTRS_DB_MONGODB_COLLECTION,
+  SEMATTRS_DB_MSSQL_INSTANCE_NAME: () => SEMATTRS_DB_MSSQL_INSTANCE_NAME,
+  SEMATTRS_DB_NAME: () => SEMATTRS_DB_NAME,
+  SEMATTRS_DB_OPERATION: () => SEMATTRS_DB_OPERATION,
+  SEMATTRS_DB_REDIS_DATABASE_INDEX: () => SEMATTRS_DB_REDIS_DATABASE_INDEX,
+  SEMATTRS_DB_SQL_TABLE: () => SEMATTRS_DB_SQL_TABLE,
+  SEMATTRS_DB_STATEMENT: () => SEMATTRS_DB_STATEMENT,
+  SEMATTRS_DB_SYSTEM: () => SEMATTRS_DB_SYSTEM,
+  SEMATTRS_DB_USER: () => SEMATTRS_DB_USER,
+  SEMATTRS_ENDUSER_ID: () => SEMATTRS_ENDUSER_ID,
+  SEMATTRS_ENDUSER_ROLE: () => SEMATTRS_ENDUSER_ROLE,
+  SEMATTRS_ENDUSER_SCOPE: () => SEMATTRS_ENDUSER_SCOPE,
+  SEMATTRS_EXCEPTION_ESCAPED: () => SEMATTRS_EXCEPTION_ESCAPED,
+  SEMATTRS_EXCEPTION_MESSAGE: () => SEMATTRS_EXCEPTION_MESSAGE,
+  SEMATTRS_EXCEPTION_STACKTRACE: () => SEMATTRS_EXCEPTION_STACKTRACE,
+  SEMATTRS_EXCEPTION_TYPE: () => SEMATTRS_EXCEPTION_TYPE,
+  SEMATTRS_FAAS_COLDSTART: () => SEMATTRS_FAAS_COLDSTART,
+  SEMATTRS_FAAS_CRON: () => SEMATTRS_FAAS_CRON,
+  SEMATTRS_FAAS_DOCUMENT_COLLECTION: () => SEMATTRS_FAAS_DOCUMENT_COLLECTION,
+  SEMATTRS_FAAS_DOCUMENT_NAME: () => SEMATTRS_FAAS_DOCUMENT_NAME,
+  SEMATTRS_FAAS_DOCUMENT_OPERATION: () => SEMATTRS_FAAS_DOCUMENT_OPERATION,
+  SEMATTRS_FAAS_DOCUMENT_TIME: () => SEMATTRS_FAAS_DOCUMENT_TIME,
+  SEMATTRS_FAAS_EXECUTION: () => SEMATTRS_FAAS_EXECUTION,
+  SEMATTRS_FAAS_INVOKED_NAME: () => SEMATTRS_FAAS_INVOKED_NAME,
+  SEMATTRS_FAAS_INVOKED_PROVIDER: () => SEMATTRS_FAAS_INVOKED_PROVIDER,
+  SEMATTRS_FAAS_INVOKED_REGION: () => SEMATTRS_FAAS_INVOKED_REGION,
+  SEMATTRS_FAAS_TIME: () => SEMATTRS_FAAS_TIME,
+  SEMATTRS_FAAS_TRIGGER: () => SEMATTRS_FAAS_TRIGGER,
+  SEMATTRS_HTTP_CLIENT_IP: () => SEMATTRS_HTTP_CLIENT_IP,
+  SEMATTRS_HTTP_FLAVOR: () => SEMATTRS_HTTP_FLAVOR,
+  SEMATTRS_HTTP_HOST: () => SEMATTRS_HTTP_HOST,
+  SEMATTRS_HTTP_METHOD: () => SEMATTRS_HTTP_METHOD,
+  SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH: () => SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH,
+  SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED: () => SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED,
+  SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH: () => SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH,
+  SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED: () => SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED,
+  SEMATTRS_HTTP_ROUTE: () => SEMATTRS_HTTP_ROUTE,
+  SEMATTRS_HTTP_SCHEME: () => SEMATTRS_HTTP_SCHEME,
+  SEMATTRS_HTTP_SERVER_NAME: () => SEMATTRS_HTTP_SERVER_NAME,
+  SEMATTRS_HTTP_STATUS_CODE: () => SEMATTRS_HTTP_STATUS_CODE,
+  SEMATTRS_HTTP_TARGET: () => SEMATTRS_HTTP_TARGET,
+  SEMATTRS_HTTP_URL: () => SEMATTRS_HTTP_URL,
+  SEMATTRS_HTTP_USER_AGENT: () => SEMATTRS_HTTP_USER_AGENT,
+  SEMATTRS_MESSAGE_COMPRESSED_SIZE: () => SEMATTRS_MESSAGE_COMPRESSED_SIZE,
+  SEMATTRS_MESSAGE_ID: () => SEMATTRS_MESSAGE_ID,
+  SEMATTRS_MESSAGE_TYPE: () => SEMATTRS_MESSAGE_TYPE,
+  SEMATTRS_MESSAGE_UNCOMPRESSED_SIZE: () => SEMATTRS_MESSAGE_UNCOMPRESSED_SIZE,
+  SEMATTRS_MESSAGING_CONSUMER_ID: () => SEMATTRS_MESSAGING_CONSUMER_ID,
+  SEMATTRS_MESSAGING_CONVERSATION_ID: () => SEMATTRS_MESSAGING_CONVERSATION_ID,
+  SEMATTRS_MESSAGING_DESTINATION: () => SEMATTRS_MESSAGING_DESTINATION,
+  SEMATTRS_MESSAGING_DESTINATION_KIND: () => SEMATTRS_MESSAGING_DESTINATION_KIND,
+  SEMATTRS_MESSAGING_KAFKA_CLIENT_ID: () => SEMATTRS_MESSAGING_KAFKA_CLIENT_ID,
+  SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP: () => SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP,
+  SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY: () => SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY,
+  SEMATTRS_MESSAGING_KAFKA_PARTITION: () => SEMATTRS_MESSAGING_KAFKA_PARTITION,
+  SEMATTRS_MESSAGING_KAFKA_TOMBSTONE: () => SEMATTRS_MESSAGING_KAFKA_TOMBSTONE,
+  SEMATTRS_MESSAGING_MESSAGE_ID: () => SEMATTRS_MESSAGING_MESSAGE_ID,
+  SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES: () => SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES,
+  SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES: () => SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES,
+  SEMATTRS_MESSAGING_OPERATION: () => SEMATTRS_MESSAGING_OPERATION,
+  SEMATTRS_MESSAGING_PROTOCOL: () => SEMATTRS_MESSAGING_PROTOCOL,
+  SEMATTRS_MESSAGING_PROTOCOL_VERSION: () => SEMATTRS_MESSAGING_PROTOCOL_VERSION,
+  SEMATTRS_MESSAGING_RABBITMQ_ROUTING_KEY: () => SEMATTRS_MESSAGING_RABBITMQ_ROUTING_KEY,
+  SEMATTRS_MESSAGING_SYSTEM: () => SEMATTRS_MESSAGING_SYSTEM,
+  SEMATTRS_MESSAGING_TEMP_DESTINATION: () => SEMATTRS_MESSAGING_TEMP_DESTINATION,
+  SEMATTRS_MESSAGING_URL: () => SEMATTRS_MESSAGING_URL,
+  SEMATTRS_NET_HOST_CARRIER_ICC: () => SEMATTRS_NET_HOST_CARRIER_ICC,
+  SEMATTRS_NET_HOST_CARRIER_MCC: () => SEMATTRS_NET_HOST_CARRIER_MCC,
+  SEMATTRS_NET_HOST_CARRIER_MNC: () => SEMATTRS_NET_HOST_CARRIER_MNC,
+  SEMATTRS_NET_HOST_CARRIER_NAME: () => SEMATTRS_NET_HOST_CARRIER_NAME,
+  SEMATTRS_NET_HOST_CONNECTION_SUBTYPE: () => SEMATTRS_NET_HOST_CONNECTION_SUBTYPE,
+  SEMATTRS_NET_HOST_CONNECTION_TYPE: () => SEMATTRS_NET_HOST_CONNECTION_TYPE,
+  SEMATTRS_NET_HOST_IP: () => SEMATTRS_NET_HOST_IP,
+  SEMATTRS_NET_HOST_NAME: () => SEMATTRS_NET_HOST_NAME,
+  SEMATTRS_NET_HOST_PORT: () => SEMATTRS_NET_HOST_PORT,
+  SEMATTRS_NET_PEER_IP: () => SEMATTRS_NET_PEER_IP,
+  SEMATTRS_NET_PEER_NAME: () => SEMATTRS_NET_PEER_NAME,
+  SEMATTRS_NET_PEER_PORT: () => SEMATTRS_NET_PEER_PORT,
+  SEMATTRS_NET_TRANSPORT: () => SEMATTRS_NET_TRANSPORT,
+  SEMATTRS_PEER_SERVICE: () => SEMATTRS_PEER_SERVICE,
+  SEMATTRS_RPC_GRPC_STATUS_CODE: () => SEMATTRS_RPC_GRPC_STATUS_CODE,
+  SEMATTRS_RPC_JSONRPC_ERROR_CODE: () => SEMATTRS_RPC_JSONRPC_ERROR_CODE,
+  SEMATTRS_RPC_JSONRPC_ERROR_MESSAGE: () => SEMATTRS_RPC_JSONRPC_ERROR_MESSAGE,
+  SEMATTRS_RPC_JSONRPC_REQUEST_ID: () => SEMATTRS_RPC_JSONRPC_REQUEST_ID,
+  SEMATTRS_RPC_JSONRPC_VERSION: () => SEMATTRS_RPC_JSONRPC_VERSION,
+  SEMATTRS_RPC_METHOD: () => SEMATTRS_RPC_METHOD,
+  SEMATTRS_RPC_SERVICE: () => SEMATTRS_RPC_SERVICE,
+  SEMATTRS_RPC_SYSTEM: () => SEMATTRS_RPC_SYSTEM,
+  SEMATTRS_THREAD_ID: () => SEMATTRS_THREAD_ID,
+  SEMATTRS_THREAD_NAME: () => SEMATTRS_THREAD_NAME,
+  SEMRESATTRS_AWS_ECS_CLUSTER_ARN: () => SEMRESATTRS_AWS_ECS_CLUSTER_ARN,
+  SEMRESATTRS_AWS_ECS_CONTAINER_ARN: () => SEMRESATTRS_AWS_ECS_CONTAINER_ARN,
+  SEMRESATTRS_AWS_ECS_LAUNCHTYPE: () => SEMRESATTRS_AWS_ECS_LAUNCHTYPE,
+  SEMRESATTRS_AWS_ECS_TASK_ARN: () => SEMRESATTRS_AWS_ECS_TASK_ARN,
+  SEMRESATTRS_AWS_ECS_TASK_FAMILY: () => SEMRESATTRS_AWS_ECS_TASK_FAMILY,
+  SEMRESATTRS_AWS_ECS_TASK_REVISION: () => SEMRESATTRS_AWS_ECS_TASK_REVISION,
+  SEMRESATTRS_AWS_EKS_CLUSTER_ARN: () => SEMRESATTRS_AWS_EKS_CLUSTER_ARN,
+  SEMRESATTRS_AWS_LOG_GROUP_ARNS: () => SEMRESATTRS_AWS_LOG_GROUP_ARNS,
+  SEMRESATTRS_AWS_LOG_GROUP_NAMES: () => SEMRESATTRS_AWS_LOG_GROUP_NAMES,
+  SEMRESATTRS_AWS_LOG_STREAM_ARNS: () => SEMRESATTRS_AWS_LOG_STREAM_ARNS,
+  SEMRESATTRS_AWS_LOG_STREAM_NAMES: () => SEMRESATTRS_AWS_LOG_STREAM_NAMES,
+  SEMRESATTRS_CLOUD_ACCOUNT_ID: () => SEMRESATTRS_CLOUD_ACCOUNT_ID,
+  SEMRESATTRS_CLOUD_AVAILABILITY_ZONE: () => SEMRESATTRS_CLOUD_AVAILABILITY_ZONE,
+  SEMRESATTRS_CLOUD_PLATFORM: () => SEMRESATTRS_CLOUD_PLATFORM,
+  SEMRESATTRS_CLOUD_PROVIDER: () => SEMRESATTRS_CLOUD_PROVIDER,
+  SEMRESATTRS_CLOUD_REGION: () => SEMRESATTRS_CLOUD_REGION,
+  SEMRESATTRS_CONTAINER_ID: () => SEMRESATTRS_CONTAINER_ID,
+  SEMRESATTRS_CONTAINER_IMAGE_NAME: () => SEMRESATTRS_CONTAINER_IMAGE_NAME,
+  SEMRESATTRS_CONTAINER_IMAGE_TAG: () => SEMRESATTRS_CONTAINER_IMAGE_TAG,
+  SEMRESATTRS_CONTAINER_NAME: () => SEMRESATTRS_CONTAINER_NAME,
+  SEMRESATTRS_CONTAINER_RUNTIME: () => SEMRESATTRS_CONTAINER_RUNTIME,
+  SEMRESATTRS_DEPLOYMENT_ENVIRONMENT: () => SEMRESATTRS_DEPLOYMENT_ENVIRONMENT,
+  SEMRESATTRS_DEVICE_ID: () => SEMRESATTRS_DEVICE_ID,
+  SEMRESATTRS_DEVICE_MODEL_IDENTIFIER: () => SEMRESATTRS_DEVICE_MODEL_IDENTIFIER,
+  SEMRESATTRS_DEVICE_MODEL_NAME: () => SEMRESATTRS_DEVICE_MODEL_NAME,
+  SEMRESATTRS_FAAS_ID: () => SEMRESATTRS_FAAS_ID,
+  SEMRESATTRS_FAAS_INSTANCE: () => SEMRESATTRS_FAAS_INSTANCE,
+  SEMRESATTRS_FAAS_MAX_MEMORY: () => SEMRESATTRS_FAAS_MAX_MEMORY,
+  SEMRESATTRS_FAAS_NAME: () => SEMRESATTRS_FAAS_NAME,
+  SEMRESATTRS_FAAS_VERSION: () => SEMRESATTRS_FAAS_VERSION,
+  SEMRESATTRS_HOST_ARCH: () => SEMRESATTRS_HOST_ARCH,
+  SEMRESATTRS_HOST_ID: () => SEMRESATTRS_HOST_ID,
+  SEMRESATTRS_HOST_IMAGE_ID: () => SEMRESATTRS_HOST_IMAGE_ID,
+  SEMRESATTRS_HOST_IMAGE_NAME: () => SEMRESATTRS_HOST_IMAGE_NAME,
+  SEMRESATTRS_HOST_IMAGE_VERSION: () => SEMRESATTRS_HOST_IMAGE_VERSION,
+  SEMRESATTRS_HOST_NAME: () => SEMRESATTRS_HOST_NAME,
+  SEMRESATTRS_HOST_TYPE: () => SEMRESATTRS_HOST_TYPE,
+  SEMRESATTRS_K8S_CLUSTER_NAME: () => SEMRESATTRS_K8S_CLUSTER_NAME,
+  SEMRESATTRS_K8S_CONTAINER_NAME: () => SEMRESATTRS_K8S_CONTAINER_NAME,
+  SEMRESATTRS_K8S_CRONJOB_NAME: () => SEMRESATTRS_K8S_CRONJOB_NAME,
+  SEMRESATTRS_K8S_CRONJOB_UID: () => SEMRESATTRS_K8S_CRONJOB_UID,
+  SEMRESATTRS_K8S_DAEMONSET_NAME: () => SEMRESATTRS_K8S_DAEMONSET_NAME,
+  SEMRESATTRS_K8S_DAEMONSET_UID: () => SEMRESATTRS_K8S_DAEMONSET_UID,
+  SEMRESATTRS_K8S_DEPLOYMENT_NAME: () => SEMRESATTRS_K8S_DEPLOYMENT_NAME,
+  SEMRESATTRS_K8S_DEPLOYMENT_UID: () => SEMRESATTRS_K8S_DEPLOYMENT_UID,
+  SEMRESATTRS_K8S_JOB_NAME: () => SEMRESATTRS_K8S_JOB_NAME,
+  SEMRESATTRS_K8S_JOB_UID: () => SEMRESATTRS_K8S_JOB_UID,
+  SEMRESATTRS_K8S_NAMESPACE_NAME: () => SEMRESATTRS_K8S_NAMESPACE_NAME,
+  SEMRESATTRS_K8S_NODE_NAME: () => SEMRESATTRS_K8S_NODE_NAME,
+  SEMRESATTRS_K8S_NODE_UID: () => SEMRESATTRS_K8S_NODE_UID,
+  SEMRESATTRS_K8S_POD_NAME: () => SEMRESATTRS_K8S_POD_NAME,
+  SEMRESATTRS_K8S_POD_UID: () => SEMRESATTRS_K8S_POD_UID,
+  SEMRESATTRS_K8S_REPLICASET_NAME: () => SEMRESATTRS_K8S_REPLICASET_NAME,
+  SEMRESATTRS_K8S_REPLICASET_UID: () => SEMRESATTRS_K8S_REPLICASET_UID,
+  SEMRESATTRS_K8S_STATEFULSET_NAME: () => SEMRESATTRS_K8S_STATEFULSET_NAME,
+  SEMRESATTRS_K8S_STATEFULSET_UID: () => SEMRESATTRS_K8S_STATEFULSET_UID,
+  SEMRESATTRS_OS_DESCRIPTION: () => SEMRESATTRS_OS_DESCRIPTION,
+  SEMRESATTRS_OS_NAME: () => SEMRESATTRS_OS_NAME,
+  SEMRESATTRS_OS_TYPE: () => SEMRESATTRS_OS_TYPE,
+  SEMRESATTRS_OS_VERSION: () => SEMRESATTRS_OS_VERSION,
+  SEMRESATTRS_PROCESS_COMMAND: () => SEMRESATTRS_PROCESS_COMMAND,
+  SEMRESATTRS_PROCESS_COMMAND_ARGS: () => SEMRESATTRS_PROCESS_COMMAND_ARGS,
+  SEMRESATTRS_PROCESS_COMMAND_LINE: () => SEMRESATTRS_PROCESS_COMMAND_LINE,
+  SEMRESATTRS_PROCESS_EXECUTABLE_NAME: () => SEMRESATTRS_PROCESS_EXECUTABLE_NAME,
+  SEMRESATTRS_PROCESS_EXECUTABLE_PATH: () => SEMRESATTRS_PROCESS_EXECUTABLE_PATH,
+  SEMRESATTRS_PROCESS_OWNER: () => SEMRESATTRS_PROCESS_OWNER,
+  SEMRESATTRS_PROCESS_PID: () => SEMRESATTRS_PROCESS_PID,
+  SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION: () => SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION,
+  SEMRESATTRS_PROCESS_RUNTIME_NAME: () => SEMRESATTRS_PROCESS_RUNTIME_NAME,
+  SEMRESATTRS_PROCESS_RUNTIME_VERSION: () => SEMRESATTRS_PROCESS_RUNTIME_VERSION,
+  SEMRESATTRS_SERVICE_INSTANCE_ID: () => SEMRESATTRS_SERVICE_INSTANCE_ID,
+  SEMRESATTRS_SERVICE_NAME: () => SEMRESATTRS_SERVICE_NAME,
+  SEMRESATTRS_SERVICE_NAMESPACE: () => SEMRESATTRS_SERVICE_NAMESPACE,
+  SEMRESATTRS_SERVICE_VERSION: () => SEMRESATTRS_SERVICE_VERSION,
+  SEMRESATTRS_TELEMETRY_AUTO_VERSION: () => SEMRESATTRS_TELEMETRY_AUTO_VERSION,
+  SEMRESATTRS_TELEMETRY_SDK_LANGUAGE: () => SEMRESATTRS_TELEMETRY_SDK_LANGUAGE,
+  SEMRESATTRS_TELEMETRY_SDK_NAME: () => SEMRESATTRS_TELEMETRY_SDK_NAME,
+  SEMRESATTRS_TELEMETRY_SDK_VERSION: () => SEMRESATTRS_TELEMETRY_SDK_VERSION,
+  SEMRESATTRS_WEBENGINE_DESCRIPTION: () => SEMRESATTRS_WEBENGINE_DESCRIPTION,
+  SEMRESATTRS_WEBENGINE_NAME: () => SEMRESATTRS_WEBENGINE_NAME,
+  SEMRESATTRS_WEBENGINE_VERSION: () => SEMRESATTRS_WEBENGINE_VERSION,
+  SemanticAttributes: () => SemanticAttributes,
+  SemanticResourceAttributes: () => SemanticResourceAttributes,
+  TELEMETRYSDKLANGUAGEVALUES_CPP: () => TELEMETRYSDKLANGUAGEVALUES_CPP,
+  TELEMETRYSDKLANGUAGEVALUES_DOTNET: () => TELEMETRYSDKLANGUAGEVALUES_DOTNET,
+  TELEMETRYSDKLANGUAGEVALUES_ERLANG: () => TELEMETRYSDKLANGUAGEVALUES_ERLANG,
+  TELEMETRYSDKLANGUAGEVALUES_GO: () => TELEMETRYSDKLANGUAGEVALUES_GO,
+  TELEMETRYSDKLANGUAGEVALUES_JAVA: () => TELEMETRYSDKLANGUAGEVALUES_JAVA,
+  TELEMETRYSDKLANGUAGEVALUES_NODEJS: () => TELEMETRYSDKLANGUAGEVALUES_NODEJS,
+  TELEMETRYSDKLANGUAGEVALUES_PHP: () => TELEMETRYSDKLANGUAGEVALUES_PHP,
+  TELEMETRYSDKLANGUAGEVALUES_PYTHON: () => TELEMETRYSDKLANGUAGEVALUES_PYTHON,
+  TELEMETRYSDKLANGUAGEVALUES_RUBY: () => TELEMETRYSDKLANGUAGEVALUES_RUBY,
+  TELEMETRYSDKLANGUAGEVALUES_WEBJS: () => TELEMETRYSDKLANGUAGEVALUES_WEBJS,
+  TelemetrySdkLanguageValues: () => TelemetrySdkLanguageValues
+});
+var init_esm2 = __esm({
+  "../../node_modules/@opentelemetry/semantic-conventions/build/esm/index.js"() {
+    "use strict";
+    init_esm_shims();
+    init_trace2();
+    init_resource();
+  }
+});
+
+export {
+  DiagLogLevel,
+  baggageEntryMetadataFromString,
+  createContextKey,
+  TraceFlags,
+  isValidTraceId,
+  isSpanContextValid,
+  SamplingDecision,
+  context,
+  diag2 as diag,
+  metrics,
+  propagation,
+  trace,
+  esm_exports,
+  init_esm,
+  SEMATTRS_HTTP_ROUTE,
+  SEMRESATTRS_PROCESS_RUNTIME_NAME,
+  SEMRESATTRS_TELEMETRY_SDK_NAME,
+  SEMRESATTRS_TELEMETRY_SDK_LANGUAGE,
+  SEMRESATTRS_TELEMETRY_SDK_VERSION,
+  TELEMETRYSDKLANGUAGEVALUES_NODEJS,
+  esm_exports2,
+  init_esm2
+};
+//# sourceMappingURL=chunk-YU54OBFT.js.map