";
+ 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$1, true);
+ };
+ self$1.setLogger = setLogger;
+ self$1.disable = () => {
+ unregisterGlobal(API_NAME$4, self$1);
+ };
+ self$1.createComponentLogger = (options) => {
+ return new DiagComponentLogger(options);
+ };
+ self$1.verbose = _logProxy("verbose");
+ self$1.debug = _logProxy("debug");
+ self$1.info = _logProxy("info");
+ self$1.warn = _logProxy("warn");
+ self$1.error = _logProxy("error");
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js
+var BaggageImpl;
+var init_baggage_impl = __esmMin((() => {
+ BaggageImpl = class BaggageImpl {
+ constructor(entries) {
+ this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+ }
+ getEntry(key) {
+ const entry = this._entries.get(key);
+ if (!entry) return;
+ return Object.assign({}, entry);
+ }
+ getAllEntries() {
+ return Array.from(this._entries.entries());
+ }
+ setEntry(key, entry) {
+ const newBaggage = new BaggageImpl(this._entries);
+ newBaggage._entries.set(key, entry);
+ return newBaggage;
+ }
+ removeEntry(key) {
+ const newBaggage = new BaggageImpl(this._entries);
+ newBaggage._entries.delete(key);
+ return newBaggage;
+ }
+ removeEntries(...keys) {
+ const newBaggage = new BaggageImpl(this._entries);
+ for (const key of keys) newBaggage._entries.delete(key);
+ return newBaggage;
+ }
+ clear() {
+ return new BaggageImpl();
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js
+var baggageEntryMetadataSymbol;
+var init_symbol = __esmMin((() => {
+ baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/utils.js
+/**
+* Create a new Baggage with optional entries
+*
+* @param entries An array of baggage entries the new baggage should contain
+*/
+function createBaggage(entries = {}) {
+ return new BaggageImpl(new Map(Object.entries(entries)));
+}
+/**
+* Create a serializable BaggageEntryMetadata object from a string.
+*
+* @param str string metadata. Format is currently not defined by the spec and has no special meaning.
+*
+* @since 1.0.0
+*/
+function baggageEntryMetadataFromString(str$1) {
+ if (typeof str$1 !== "string") {
+ diag$1.error(`Cannot create baggage metadata from unknown type: ${typeof str$1}`);
+ str$1 = "";
+ }
+ return {
+ __TYPE__: baggageEntryMetadataSymbol,
+ toString() {
+ return str$1;
+ }
+ };
+}
+var diag$1;
+var init_utils$2 = __esmMin((() => {
+ init_diag();
+ init_baggage_impl();
+ init_symbol();
+ diag$1 = DiagAPI.instance();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/context.js
+/**
+* Get a key to uniquely identify a context value
+*
+* @since 1.0.0
+*/
+function createContextKey(description) {
+ return Symbol.for(description);
+}
+var BaseContext, ROOT_CONTEXT;
+var init_context$1 = __esmMin((() => {
+ BaseContext = class BaseContext {
+ /**
+ * Construct a new context which inherits values from an optional parent context.
+ *
+ * @param parentContext a context from which to inherit values
+ */
+ constructor(parentContext) {
+ const self$1 = this;
+ self$1._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+ self$1.getValue = (key) => self$1._currentContext.get(key);
+ self$1.setValue = (key, value) => {
+ const context$1 = new BaseContext(self$1._currentContext);
+ context$1._currentContext.set(key, value);
+ return context$1;
+ };
+ self$1.deleteValue = (key) => {
+ const context$1 = new BaseContext(self$1._currentContext);
+ context$1._currentContext.delete(key);
+ return context$1;
+ };
+ }
+ };
+ ROOT_CONTEXT = new BaseContext();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js
+var consoleMap, _originalConsoleMethods, DiagConsoleLogger;
+var init_consoleLogger = __esmMin((() => {
+ consoleMap = [
+ {
+ n: "error",
+ c: "error"
+ },
+ {
+ n: "warn",
+ c: "warn"
+ },
+ {
+ n: "info",
+ c: "info"
+ },
+ {
+ n: "debug",
+ c: "debug"
+ },
+ {
+ n: "verbose",
+ c: "trace"
+ }
+ ];
+ _originalConsoleMethods = {};
+ if (typeof console !== "undefined") {
+ for (const key of [
+ "error",
+ "warn",
+ "info",
+ "debug",
+ "trace",
+ "log"
+ ]) if (typeof console[key] === "function") _originalConsoleMethods[key] = console[key];
+ }
+ DiagConsoleLogger = class {
+ constructor() {
+ function _consoleFunc(funcName) {
+ return function(...args) {
+ let theFunc = _originalConsoleMethods[funcName];
+ if (typeof theFunc !== "function") theFunc = _originalConsoleMethods["log"];
+ if (typeof theFunc !== "function" && console) {
+ theFunc = console[funcName];
+ if (typeof theFunc !== "function") theFunc = console.log;
+ }
+ if (typeof theFunc === "function") return theFunc.apply(console, args);
+ };
+ }
+ for (let i = 0; i < consoleMap.length; i++) this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
+/**
+* Create a no-op Meter
+*
+* @since 1.3.0
+*/
+function createNoopMeter() {
+ return NOOP_METER;
+}
+var 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 = __esmMin((() => {
+ NoopMeter = class {
+ constructor() {}
+ /**
+ * @see {@link Meter.createGauge}
+ */
+ createGauge(_name, _options) {
+ return NOOP_GAUGE_METRIC;
+ }
+ /**
+ * @see {@link Meter.createHistogram}
+ */
+ createHistogram(_name, _options) {
+ return NOOP_HISTOGRAM_METRIC;
+ }
+ /**
+ * @see {@link Meter.createCounter}
+ */
+ createCounter(_name, _options) {
+ return NOOP_COUNTER_METRIC;
+ }
+ /**
+ * @see {@link Meter.createUpDownCounter}
+ */
+ createUpDownCounter(_name, _options) {
+ return NOOP_UP_DOWN_COUNTER_METRIC;
+ }
+ /**
+ * @see {@link Meter.createObservableGauge}
+ */
+ createObservableGauge(_name, _options) {
+ return NOOP_OBSERVABLE_GAUGE_METRIC;
+ }
+ /**
+ * @see {@link Meter.createObservableCounter}
+ */
+ createObservableCounter(_name, _options) {
+ return NOOP_OBSERVABLE_COUNTER_METRIC;
+ }
+ /**
+ * @see {@link Meter.createObservableUpDownCounter}
+ */
+ createObservableUpDownCounter(_name, _options) {
+ return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+ }
+ /**
+ * @see {@link Meter.addBatchObservableCallback}
+ */
+ addBatchObservableCallback(_callback, _observables) {}
+ /**
+ * @see {@link Meter.removeBatchObservableCallback}
+ */
+ removeBatchObservableCallback(_callback) {}
+ };
+ NoopMetric = class {};
+ NoopCounterMetric = class extends NoopMetric {
+ add(_value, _attributes) {}
+ };
+ NoopUpDownCounterMetric = class extends NoopMetric {
+ add(_value, _attributes) {}
+ };
+ NoopGaugeMetric = class extends NoopMetric {
+ record(_value, _attributes) {}
+ };
+ NoopHistogramMetric = class extends NoopMetric {
+ record(_value, _attributes) {}
+ };
+ NoopObservableMetric = class {
+ addCallback(_callback) {}
+ removeCallback(_callback) {}
+ };
+ NoopObservableCounterMetric = class extends NoopObservableMetric {};
+ NoopObservableGaugeMetric = class extends NoopObservableMetric {};
+ NoopObservableUpDownCounterMetric = class extends 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();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics/Metric.js
+var ValueType;
+var init_Metric = __esmMin((() => {
+ ;
+ (function(ValueType$1) {
+ ValueType$1[ValueType$1["INT"] = 0] = "INT";
+ ValueType$1[ValueType$1["DOUBLE"] = 1] = "DOUBLE";
+ })(ValueType || (ValueType = {}));
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
+var defaultTextMapGetter, defaultTextMapSetter;
+var init_TextMapPropagator = __esmMin((() => {
+ defaultTextMapGetter = {
+ get(carrier, key) {
+ if (carrier == null) return;
+ return carrier[key];
+ },
+ keys(carrier) {
+ if (carrier == null) return [];
+ return Object.keys(carrier);
+ }
+ };
+ defaultTextMapSetter = { set(carrier, key, value) {
+ if (carrier == null) return;
+ carrier[key] = value;
+ } };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var NoopContextManager;
+var init_NoopContextManager = __esmMin((() => {
+ init_context$1();
+ NoopContextManager = class {
+ active() {
+ return ROOT_CONTEXT;
+ }
+ with(_context, fn, thisArg, ...args) {
+ return fn.call(thisArg, ...args);
+ }
+ bind(_context, target) {
+ return target;
+ }
+ enable() {
+ return this;
+ }
+ disable() {
+ return this;
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/context.js
+var API_NAME$3, NOOP_CONTEXT_MANAGER, ContextAPI;
+var init_context = __esmMin((() => {
+ init_NoopContextManager();
+ init_global_utils();
+ init_diag();
+ API_NAME$3 = "context";
+ NOOP_CONTEXT_MANAGER = new NoopContextManager();
+ ContextAPI = class ContextAPI {
+ /** Empty private constructor prevents end users from constructing a new instance of the API */
+ constructor() {}
+ /** Get the singleton instance of the Context API */
+ static getInstance() {
+ if (!this._instance) this._instance = new ContextAPI();
+ return this._instance;
+ }
+ /**
+ * Set the current context manager.
+ *
+ * @returns true if the context manager was successfully registered, else false
+ */
+ setGlobalContextManager(contextManager) {
+ return registerGlobal(API_NAME$3, contextManager, DiagAPI.instance());
+ }
+ /**
+ * Get the currently active context
+ */
+ active() {
+ return this._getContextManager().active();
+ }
+ /**
+ * Execute a function with an active context
+ *
+ * @param context context to be active during function execution
+ * @param fn function to execute in a context
+ * @param thisArg optional receiver to be used for calling fn
+ * @param args optional arguments forwarded to fn
+ */
+ with(context$1, fn, thisArg, ...args) {
+ return this._getContextManager().with(context$1, fn, thisArg, ...args);
+ }
+ /**
+ * Bind a context to a target function or event emitter
+ *
+ * @param context context to bind to the event emitter or function. Defaults to the currently active context
+ * @param target function or event emitter to bind
+ */
+ bind(context$1, target) {
+ return this._getContextManager().bind(context$1, target);
+ }
+ _getContextManager() {
+ return getGlobal(API_NAME$3) || NOOP_CONTEXT_MANAGER;
+ }
+ /** Disable and remove the global context manager */
+ disable() {
+ this._getContextManager().disable();
+ unregisterGlobal(API_NAME$3, DiagAPI.instance());
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+var TraceFlags;
+var init_trace_flags = __esmMin((() => {
+ ;
+ (function(TraceFlags$1) {
+ /** Represents no flag set. */
+ TraceFlags$1[TraceFlags$1["NONE"] = 0] = "NONE";
+ /** Bit to represent whether trace is sampled in trace flags. */
+ TraceFlags$1[TraceFlags$1["SAMPLED"] = 1] = "SAMPLED";
+ })(TraceFlags || (TraceFlags = {}));
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
+var init_invalid_span_constants = __esmMin((() => {
+ init_trace_flags();
+ INVALID_SPANID = "0000000000000000";
+ INVALID_TRACEID = "00000000000000000000000000000000";
+ INVALID_SPAN_CONTEXT = {
+ traceId: INVALID_TRACEID,
+ spanId: INVALID_SPANID,
+ traceFlags: TraceFlags.NONE
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+var NonRecordingSpan;
+var init_NonRecordingSpan = __esmMin((() => {
+ init_invalid_span_constants();
+ NonRecordingSpan = class {
+ constructor(spanContext = INVALID_SPAN_CONTEXT) {
+ this._spanContext = spanContext;
+ }
+ spanContext() {
+ return this._spanContext;
+ }
+ setAttribute(_key, _value) {
+ return this;
+ }
+ setAttributes(_attributes) {
+ return this;
+ }
+ addEvent(_name, _attributes) {
+ return this;
+ }
+ addLink(_link) {
+ return this;
+ }
+ addLinks(_links) {
+ return this;
+ }
+ setStatus(_status) {
+ return this;
+ }
+ updateName(_name) {
+ return this;
+ }
+ end(_endTime) {}
+ isRecording() {
+ return false;
+ }
+ recordException(_exception, _time) {}
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
+/**
+* Return the span if one exists
+*
+* @param context context to get span from
+*/
+function getSpan(context$1) {
+ return context$1.getValue(SPAN_KEY) || void 0;
+}
+/**
+* Gets the span from the current context, if one exists.
+*/
+function getActiveSpan() {
+ return getSpan(ContextAPI.getInstance().active());
+}
+/**
+* Set the span on a context
+*
+* @param context context to use as parent
+* @param span span to set active
+*/
+function setSpan(context$1, span) {
+ return context$1.setValue(SPAN_KEY, span);
+}
+/**
+* Remove current span stored in the context
+*
+* @param context context to delete span from
+*/
+function deleteSpan(context$1) {
+ return context$1.deleteValue(SPAN_KEY);
+}
+/**
+* Wrap span context in a NoopSpan and set as span in a new
+* context
+*
+* @param context context to set active span on
+* @param spanContext span context to be wrapped
+*/
+function setSpanContext(context$1, spanContext) {
+ return setSpan(context$1, new NonRecordingSpan(spanContext));
+}
+/**
+* Get the span context of the span if it exists.
+*
+* @param context context to get values from
+*/
+function getSpanContext(context$1) {
+ var _a;
+ return (_a = getSpan(context$1)) === null || _a === void 0 ? void 0 : _a.spanContext();
+}
+var SPAN_KEY;
+var init_context_utils = __esmMin((() => {
+ init_context$1();
+ init_NonRecordingSpan();
+ init_context();
+ SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+function isValidHex(id, length) {
+ if (typeof id !== "string" || id.length !== length) return false;
+ let r = 0;
+ for (let i = 0; i < id.length; i += 4) r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+ return r === length;
+}
+/**
+* @since 1.0.0
+*/
+function isValidTraceId(traceId) {
+ return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
+}
+/**
+* @since 1.0.0
+*/
+function isValidSpanId(spanId) {
+ return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
+}
+/**
+* Returns true if this {@link SpanContext} is valid.
+* @return true if this {@link SpanContext} is valid.
+*
+* @since 1.0.0
+*/
+function isSpanContextValid(spanContext) {
+ return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+/**
+* Wrap the given {@link SpanContext} in a new non-recording {@link Span}
+*
+* @param spanContext span context to be wrapped
+* @returns a new non-recording {@link Span} with the provided context
+*/
+function wrapSpanContext(spanContext) {
+ return new NonRecordingSpan(spanContext);
+}
+var isHex;
+var init_spancontext_utils = __esmMin((() => {
+ init_invalid_span_constants();
+ init_NonRecordingSpan();
+ isHex = new Uint8Array([
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1
+ ]);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+function isSpanContext(spanContext) {
+ return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+}
+var contextApi, NoopTracer;
+var init_NoopTracer = __esmMin((() => {
+ init_context();
+ init_context_utils();
+ init_NonRecordingSpan();
+ init_spancontext_utils();
+ contextApi = ContextAPI.getInstance();
+ NoopTracer = class {
+ startSpan(name, options, context$1 = contextApi.active()) {
+ if (Boolean(options === null || options === void 0 ? void 0 : options.root)) return new NonRecordingSpan();
+ const parentFromContext = context$1 && getSpanContext(context$1);
+ if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) return new NonRecordingSpan(parentFromContext);
+ else return new NonRecordingSpan();
+ }
+ startActiveSpan(name, arg2, arg3, arg4) {
+ let opts;
+ let ctx;
+ let 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;
+ }
+ const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+ const span = this.startSpan(name, opts, parentContext);
+ const contextWithSpanSet = setSpan(parentContext, span);
+ return contextApi.with(contextWithSpanSet, fn, void 0, span);
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+var NOOP_TRACER, ProxyTracer;
+var init_ProxyTracer = __esmMin((() => {
+ init_NoopTracer();
+ NOOP_TRACER = new NoopTracer();
+ ProxyTracer = class {
+ constructor(provider, name, version, options) {
+ this._provider = provider;
+ this.name = name;
+ this.version = version;
+ this.options = options;
+ }
+ startSpan(name, options, context$1) {
+ return this._getTracer().startSpan(name, options, context$1);
+ }
+ startActiveSpan(_name, _options, _context, _fn) {
+ const tracer = this._getTracer();
+ return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+ }
+ /**
+ * Try to get a tracer from the proxy tracer provider.
+ * If the proxy tracer provider has no delegate, return a noop tracer.
+ */
+ _getTracer() {
+ if (this._delegate) return this._delegate;
+ const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+ if (!tracer) return NOOP_TRACER;
+ this._delegate = tracer;
+ return this._delegate;
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+var NoopTracerProvider;
+var init_NoopTracerProvider = __esmMin((() => {
+ init_NoopTracer();
+ NoopTracerProvider = class {
+ getTracer(_name, _version, _options) {
+ return new NoopTracer();
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+var NOOP_TRACER_PROVIDER, ProxyTracerProvider;
+var init_ProxyTracerProvider = __esmMin((() => {
+ init_ProxyTracer();
+ init_NoopTracerProvider();
+ NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+ ProxyTracerProvider = class {
+ /**
+ * Get a {@link ProxyTracer}
+ */
+ getTracer(name, version, options) {
+ var _a;
+ return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
+ }
+ getDelegate() {
+ var _a;
+ return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+ }
+ /**
+ * Set the delegate tracer provider
+ */
+ setDelegate(delegate) {
+ this._delegate = delegate;
+ }
+ getDelegateTracer(name, version, options) {
+ var _a;
+ return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js
+var SamplingDecision;
+var init_SamplingResult = __esmMin((() => {
+ ;
+ (function(SamplingDecision$1) {
+ /**
+ * `Span.isRecording() === false`, span will not be recorded and all events
+ * and attributes will be dropped.
+ */
+ SamplingDecision$1[SamplingDecision$1["NOT_RECORD"] = 0] = "NOT_RECORD";
+ /**
+ * `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}
+ * MUST NOT be set.
+ */
+ SamplingDecision$1[SamplingDecision$1["RECORD"] = 1] = "RECORD";
+ /**
+ * `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}
+ * MUST be set.
+ */
+ SamplingDecision$1[SamplingDecision$1["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+ })(SamplingDecision || (SamplingDecision = {}));
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
+var SpanKind;
+var init_span_kind = __esmMin((() => {
+ ;
+ (function(SpanKind$1) {
+ /** Default value. Indicates that the span is used internally. */
+ SpanKind$1[SpanKind$1["INTERNAL"] = 0] = "INTERNAL";
+ /**
+ * Indicates that the span covers server-side handling of an RPC or other
+ * remote request.
+ */
+ SpanKind$1[SpanKind$1["SERVER"] = 1] = "SERVER";
+ /**
+ * Indicates that the span covers the client-side wrapper around an RPC or
+ * other remote request.
+ */
+ SpanKind$1[SpanKind$1["CLIENT"] = 2] = "CLIENT";
+ /**
+ * Indicates that the span describes producer sending a message to a
+ * broker. Unlike client and server, there is no direct critical path latency
+ * relationship between producer and consumer spans.
+ */
+ SpanKind$1[SpanKind$1["PRODUCER"] = 3] = "PRODUCER";
+ /**
+ * Indicates that the span describes consumer receiving a message from a
+ * broker. Unlike client and server, there is no direct critical path latency
+ * relationship between producer and consumer spans.
+ */
+ SpanKind$1[SpanKind$1["CONSUMER"] = 4] = "CONSUMER";
+ })(SpanKind || (SpanKind = {}));
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/status.js
+var SpanStatusCode;
+var init_status = __esmMin((() => {
+ ;
+ (function(SpanStatusCode$1) {
+ /**
+ * The default status.
+ */
+ SpanStatusCode$1[SpanStatusCode$1["UNSET"] = 0] = "UNSET";
+ /**
+ * The operation has been validated by an Application developer or
+ * Operator to have completed successfully.
+ */
+ SpanStatusCode$1[SpanStatusCode$1["OK"] = 1] = "OK";
+ /**
+ * The operation contains an error.
+ */
+ SpanStatusCode$1[SpanStatusCode$1["ERROR"] = 2] = "ERROR";
+ })(SpanStatusCode || (SpanStatusCode = {}));
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js
+/**
+* Key is opaque string up to 256 characters printable. It MUST begin with a
+* lowercase letter, and can only contain lowercase letters a-z, digits 0-9,
+* underscores _, dashes -, asterisks *, and forward slashes /.
+* For multi-tenant vendor scenarios, an at sign (@) can be used to prefix the
+* vendor name. Vendors SHOULD set the tenant ID at the beginning of the key.
+* see https://www.w3.org/TR/trace-context/#key
+*/
+function validateKey(key) {
+ return VALID_KEY_REGEX.test(key);
+}
+/**
+* Value is opaque string up to 256 characters printable ASCII RFC0020
+* characters (i.e., the range 0x20 to 0x7E) except comma , and =.
+*/
+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 = __esmMin((() => {
+ 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 = /* @__PURE__ */ new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+ VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+ INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/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 = __esmMin((() => {
+ init_tracestate_validators();
+ MAX_TRACE_STATE_ITEMS = 32;
+ MAX_TRACE_STATE_LEN = 512;
+ LIST_MEMBERS_SEPARATOR = ",";
+ LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+ TraceStateImpl = class TraceStateImpl {
+ constructor(rawTraceState) {
+ this._internalState = /* @__PURE__ */ new Map();
+ if (rawTraceState) this._parse(rawTraceState);
+ }
+ set(key, value) {
+ const traceState = this._clone();
+ if (traceState._internalState.has(key)) traceState._internalState.delete(key);
+ traceState._internalState.set(key, value);
+ return traceState;
+ }
+ unset(key) {
+ const traceState = this._clone();
+ traceState._internalState.delete(key);
+ return traceState;
+ }
+ get(key) {
+ return this._internalState.get(key);
+ }
+ serialize() {
+ return Array.from(this._internalState.keys()).reduceRight((agg, key) => {
+ agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+ return agg;
+ }, []).join(LIST_MEMBERS_SEPARATOR);
+ }
+ _parse(rawTraceState) {
+ if (rawTraceState.length > MAX_TRACE_STATE_LEN) return;
+ this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reduceRight((agg, part) => {
+ const listMember = part.trim();
+ const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+ if (i !== -1) {
+ const key = listMember.slice(0, i);
+ const value = listMember.slice(i + 1, part.length);
+ if (validateKey(key) && validateValue(value)) agg.set(key, value);
+ }
+ 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));
+ }
+ _keys() {
+ return Array.from(this._internalState.keys()).reverse();
+ }
+ _clone() {
+ const traceState = new TraceStateImpl();
+ traceState._internalState = new Map(this._internalState);
+ return traceState;
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js
+/**
+* @since 1.1.0
+*/
+function createTraceState(rawTraceState) {
+ return new TraceStateImpl(rawTraceState);
+}
+var init_utils$1 = __esmMin((() => {
+ init_tracestate_impl();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context-api.js
+var context;
+var init_context_api = __esmMin((() => {
+ init_context();
+ context = ContextAPI.getInstance();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag-api.js
+var diag;
+var init_diag_api = __esmMin((() => {
+ init_diag();
+ diag = DiagAPI.instance();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
+var NoopMeterProvider, NOOP_METER_PROVIDER;
+var init_NoopMeterProvider = __esmMin((() => {
+ init_NoopMeter();
+ NoopMeterProvider = class {
+ getMeter(_name, _version, _options) {
+ return NOOP_METER;
+ }
+ };
+ NOOP_METER_PROVIDER = new NoopMeterProvider();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/metrics.js
+var API_NAME$2, MetricsAPI;
+var init_metrics = __esmMin((() => {
+ init_NoopMeterProvider();
+ init_global_utils();
+ init_diag();
+ API_NAME$2 = "metrics";
+ MetricsAPI = class MetricsAPI {
+ /** Empty private constructor prevents end users from constructing a new instance of the API */
+ constructor() {}
+ /** Get the singleton instance of the Metrics API */
+ static getInstance() {
+ if (!this._instance) this._instance = new MetricsAPI();
+ return this._instance;
+ }
+ /**
+ * Set the current global meter provider.
+ * Returns true if the meter provider was successfully registered, else false.
+ */
+ setGlobalMeterProvider(provider) {
+ return registerGlobal(API_NAME$2, provider, DiagAPI.instance());
+ }
+ /**
+ * Returns the global meter provider.
+ */
+ getMeterProvider() {
+ return getGlobal(API_NAME$2) || NOOP_METER_PROVIDER;
+ }
+ /**
+ * Returns a meter from the global meter provider.
+ */
+ getMeter(name, version, options) {
+ return this.getMeterProvider().getMeter(name, version, options);
+ }
+ /** Remove the global meter provider */
+ disable() {
+ unregisterGlobal(API_NAME$2, DiagAPI.instance());
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics-api.js
+var metrics;
+var init_metrics_api = __esmMin((() => {
+ init_metrics();
+ metrics = MetricsAPI.getInstance();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js
+var NoopTextMapPropagator;
+var init_NoopTextMapPropagator = __esmMin((() => {
+ NoopTextMapPropagator = class {
+ /** Noop inject function does nothing */
+ inject(_context, _carrier) {}
+ /** Noop extract function does nothing and returns the input context */
+ extract(context$1, _carrier) {
+ return context$1;
+ }
+ fields() {
+ return [];
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js
+/**
+* Retrieve the current baggage from the given context
+*
+* @param {Context} Context that manage all context values
+* @returns {Baggage} Extracted baggage from the context
+*/
+function getBaggage(context$1) {
+ return context$1.getValue(BAGGAGE_KEY) || void 0;
+}
+/**
+* Retrieve the current baggage from the active/current context
+*
+* @returns {Baggage} Extracted baggage from the context
+*/
+function getActiveBaggage() {
+ return getBaggage(ContextAPI.getInstance().active());
+}
+/**
+* Store a baggage in the given context
+*
+* @param {Context} Context that manage all context values
+* @param {Baggage} baggage that will be set in the actual context
+*/
+function setBaggage(context$1, baggage) {
+ return context$1.setValue(BAGGAGE_KEY, baggage);
+}
+/**
+* Delete the baggage stored in the given context
+*
+* @param {Context} Context that manage all context values
+*/
+function deleteBaggage(context$1) {
+ return context$1.deleteValue(BAGGAGE_KEY);
+}
+var BAGGAGE_KEY;
+var init_context_helpers = __esmMin((() => {
+ init_context();
+ init_context$1();
+ BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/propagation.js
+var API_NAME$1, NOOP_TEXT_MAP_PROPAGATOR, PropagationAPI;
+var init_propagation = __esmMin((() => {
+ init_global_utils();
+ init_NoopTextMapPropagator();
+ init_TextMapPropagator();
+ init_context_helpers();
+ init_utils$2();
+ init_diag();
+ API_NAME$1 = "propagation";
+ NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
+ PropagationAPI = class PropagationAPI {
+ /** Empty private constructor prevents end users from constructing a new instance of the API */
+ constructor() {
+ this.createBaggage = createBaggage;
+ this.getBaggage = getBaggage;
+ this.getActiveBaggage = getActiveBaggage;
+ this.setBaggage = setBaggage;
+ this.deleteBaggage = deleteBaggage;
+ }
+ /** Get the singleton instance of the Propagator API */
+ static getInstance() {
+ if (!this._instance) this._instance = new PropagationAPI();
+ return this._instance;
+ }
+ /**
+ * Set the current propagator.
+ *
+ * @returns true if the propagator was successfully registered, else false
+ */
+ setGlobalPropagator(propagator) {
+ return registerGlobal(API_NAME$1, propagator, DiagAPI.instance());
+ }
+ /**
+ * Inject context into a carrier to be propagated inter-process
+ *
+ * @param context Context carrying tracing data to inject
+ * @param carrier carrier to inject context into
+ * @param setter Function used to set values on the carrier
+ */
+ inject(context$1, carrier, setter = defaultTextMapSetter) {
+ return this._getGlobalPropagator().inject(context$1, carrier, setter);
+ }
+ /**
+ * Extract context from a carrier
+ *
+ * @param context Context which the newly created context will inherit from
+ * @param carrier Carrier to extract context from
+ * @param getter Function used to extract keys from a carrier
+ */
+ extract(context$1, carrier, getter = defaultTextMapGetter) {
+ return this._getGlobalPropagator().extract(context$1, carrier, getter);
+ }
+ /**
+ * Return a list of all fields which may be used by the propagator.
+ */
+ fields() {
+ return this._getGlobalPropagator().fields();
+ }
+ /** Remove the global propagator */
+ disable() {
+ unregisterGlobal(API_NAME$1, DiagAPI.instance());
+ }
+ _getGlobalPropagator() {
+ return getGlobal(API_NAME$1) || NOOP_TEXT_MAP_PROPAGATOR;
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation-api.js
+var propagation;
+var init_propagation_api = __esmMin((() => {
+ init_propagation();
+ propagation = PropagationAPI.getInstance();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/trace.js
+var API_NAME, TraceAPI;
+var init_trace$1 = __esmMin((() => {
+ init_global_utils();
+ init_ProxyTracerProvider();
+ init_spancontext_utils();
+ init_context_utils();
+ init_diag();
+ API_NAME = "trace";
+ TraceAPI = class TraceAPI {
+ /** Empty private constructor prevents end users from constructing a new instance of the API */
+ constructor() {
+ 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;
+ }
+ /** Get the singleton instance of the Trace API */
+ static getInstance() {
+ if (!this._instance) this._instance = new TraceAPI();
+ return this._instance;
+ }
+ /**
+ * Set the current global tracer.
+ *
+ * @returns true if the tracer provider was successfully registered, else false
+ */
+ setGlobalTracerProvider(provider) {
+ const success = registerGlobal(API_NAME, this._proxyTracerProvider, DiagAPI.instance());
+ if (success) this._proxyTracerProvider.setDelegate(provider);
+ return success;
+ }
+ /**
+ * Returns the global tracer provider.
+ */
+ getTracerProvider() {
+ return getGlobal(API_NAME) || this._proxyTracerProvider;
+ }
+ /**
+ * Returns a tracer from the global tracer provider.
+ */
+ getTracer(name, version) {
+ return this.getTracerProvider().getTracer(name, version);
+ }
+ /** Remove the global tracer provider */
+ disable() {
+ unregisterGlobal(API_NAME, DiagAPI.instance());
+ this._proxyTracerProvider = new ProxyTracerProvider();
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace-api.js
+var trace;
+var init_trace_api = __esmMin((() => {
+ init_trace$1();
+ trace = TraceAPI.getInstance();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/index.js
+var esm_exports$2 = /* @__PURE__ */ __exportAll({
+ 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: () => diag,
+ isSpanContextValid: () => isSpanContextValid,
+ isValidSpanId: () => isValidSpanId,
+ isValidTraceId: () => isValidTraceId,
+ metrics: () => metrics,
+ propagation: () => propagation,
+ trace: () => trace
+});
+var esm_default;
+var init_esm$2 = __esmMin((() => {
+ init_utils$2();
+ init_context$1();
+ 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_utils$1();
+ 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,
+ metrics,
+ propagation,
+ trace
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/trace/suppress-tracing.js
+var require_suppress_tracing$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.isTracingSuppressed = exports.unsuppressTracing = exports.suppressTracing = void 0;
+ const SUPPRESS_TRACING_KEY = (0, (init_esm$2(), __toCommonJS(esm_exports$2)).createContextKey)("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+ function suppressTracing(context$1) {
+ return context$1.setValue(SUPPRESS_TRACING_KEY, true);
+ }
+ exports.suppressTracing = suppressTracing;
+ function unsuppressTracing(context$1) {
+ return context$1.deleteValue(SUPPRESS_TRACING_KEY);
+ }
+ exports.unsuppressTracing = unsuppressTracing;
+ function isTracingSuppressed(context$1) {
+ return context$1.getValue(SUPPRESS_TRACING_KEY) === true;
+ }
+ exports.isTracingSuppressed = isTracingSuppressed;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/baggage/constants.js
+var require_constants$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.BAGGAGE_MAX_TOTAL_LENGTH = exports.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = exports.BAGGAGE_MAX_NAME_VALUE_PAIRS = exports.BAGGAGE_HEADER = exports.BAGGAGE_ITEMS_SEPARATOR = exports.BAGGAGE_PROPERTIES_SEPARATOR = exports.BAGGAGE_KEY_PAIR_SEPARATOR = void 0;
+ exports.BAGGAGE_KEY_PAIR_SEPARATOR = "=";
+ exports.BAGGAGE_PROPERTIES_SEPARATOR = ";";
+ exports.BAGGAGE_ITEMS_SEPARATOR = ",";
+ exports.BAGGAGE_HEADER = "baggage";
+ exports.BAGGAGE_MAX_NAME_VALUE_PAIRS = 180;
+ exports.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096;
+ exports.BAGGAGE_MAX_TOTAL_LENGTH = 8192;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/baggage/utils.js
+var require_utils$7 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.parseKeyPairsIntoRecord = exports.parsePairKeyValue = exports.getKeyPairs = exports.serializeKeyPairs = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ const constants_1 = require_constants$1();
+ function serializeKeyPairs(keyPairs) {
+ return keyPairs.reduce((hValue, current) => {
+ const value = `${hValue}${hValue !== "" ? constants_1.BAGGAGE_ITEMS_SEPARATOR : ""}${current}`;
+ return value.length > constants_1.BAGGAGE_MAX_TOTAL_LENGTH ? hValue : value;
+ }, "");
+ }
+ exports.serializeKeyPairs = serializeKeyPairs;
+ function getKeyPairs(baggage) {
+ return baggage.getAllEntries().map(([key, value]) => {
+ let entry = `${encodeURIComponent(key)}=${encodeURIComponent(value.value)}`;
+ if (value.metadata !== void 0) entry += constants_1.BAGGAGE_PROPERTIES_SEPARATOR + value.metadata.toString();
+ return entry;
+ });
+ }
+ exports.getKeyPairs = getKeyPairs;
+ function parsePairKeyValue(entry) {
+ const valueProps = entry.split(constants_1.BAGGAGE_PROPERTIES_SEPARATOR);
+ if (valueProps.length <= 0) return;
+ const keyPairPart = valueProps.shift();
+ if (!keyPairPart) return;
+ const separatorIndex = keyPairPart.indexOf(constants_1.BAGGAGE_KEY_PAIR_SEPARATOR);
+ if (separatorIndex <= 0) return;
+ const key = decodeURIComponent(keyPairPart.substring(0, separatorIndex).trim());
+ const value = decodeURIComponent(keyPairPart.substring(separatorIndex + 1).trim());
+ let metadata;
+ if (valueProps.length > 0) metadata = (0, api_1.baggageEntryMetadataFromString)(valueProps.join(constants_1.BAGGAGE_PROPERTIES_SEPARATOR));
+ return {
+ key,
+ value,
+ metadata
+ };
+ }
+ exports.parsePairKeyValue = parsePairKeyValue;
+ /**
+ * Parse a string serialized in the baggage HTTP Format (without metadata):
+ * https://github.com/w3c/baggage/blob/master/baggage/HTTP_HEADER_FORMAT.md
+ */
+ function parseKeyPairsIntoRecord(value) {
+ const result = {};
+ if (typeof value === "string" && value.length > 0) value.split(constants_1.BAGGAGE_ITEMS_SEPARATOR).forEach((entry) => {
+ const keyPair = parsePairKeyValue(entry);
+ if (keyPair !== void 0 && keyPair.value.length > 0) result[keyPair.key] = keyPair.value;
+ });
+ return result;
+ }
+ exports.parseKeyPairsIntoRecord = parseKeyPairsIntoRecord;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/baggage/propagation/W3CBaggagePropagator.js
+var require_W3CBaggagePropagator$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.W3CBaggagePropagator = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ const suppress_tracing_1 = require_suppress_tracing$1();
+ const constants_1 = require_constants$1();
+ const utils_1 = require_utils$7();
+ /**
+ * Propagates {@link Baggage} through Context format propagation.
+ *
+ * Based on the Baggage specification:
+ * https://w3c.github.io/baggage/
+ */
+ var W3CBaggagePropagator = class {
+ inject(context$1, carrier, setter) {
+ const baggage = api_1.propagation.getBaggage(context$1);
+ if (!baggage || (0, suppress_tracing_1.isTracingSuppressed)(context$1)) return;
+ const keyPairs = (0, utils_1.getKeyPairs)(baggage).filter((pair) => {
+ return pair.length <= constants_1.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS;
+ }).slice(0, constants_1.BAGGAGE_MAX_NAME_VALUE_PAIRS);
+ const headerValue = (0, utils_1.serializeKeyPairs)(keyPairs);
+ if (headerValue.length > 0) setter.set(carrier, constants_1.BAGGAGE_HEADER, headerValue);
+ }
+ extract(context$1, carrier, getter) {
+ const headerValue = getter.get(carrier, constants_1.BAGGAGE_HEADER);
+ const baggageString = Array.isArray(headerValue) ? headerValue.join(constants_1.BAGGAGE_ITEMS_SEPARATOR) : headerValue;
+ if (!baggageString) return context$1;
+ const baggage = {};
+ if (baggageString.length === 0) return context$1;
+ baggageString.split(constants_1.BAGGAGE_ITEMS_SEPARATOR).forEach((entry) => {
+ const keyPair = (0, utils_1.parsePairKeyValue)(entry);
+ if (keyPair) {
+ const baggageEntry = { value: keyPair.value };
+ if (keyPair.metadata) baggageEntry.metadata = keyPair.metadata;
+ baggage[keyPair.key] = baggageEntry;
+ }
+ });
+ if (Object.entries(baggage).length === 0) return context$1;
+ return api_1.propagation.setBaggage(context$1, api_1.propagation.createBaggage(baggage));
+ }
+ fields() {
+ return [constants_1.BAGGAGE_HEADER];
+ }
+ };
+ exports.W3CBaggagePropagator = W3CBaggagePropagator;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/common/anchored-clock.js
+var require_anchored_clock$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.AnchoredClock = void 0;
+ /**
+ * A utility for returning wall times anchored to a given point in time. Wall time measurements will
+ * not be taken from the system, but instead are computed by adding a monotonic clock time
+ * to the anchor point.
+ *
+ * This is needed because the system time can change and result in unexpected situations like
+ * spans ending before they are started. Creating an anchored clock for each local root span
+ * ensures that span timings and durations are accurate while preventing span times from drifting
+ * too far from the system clock.
+ *
+ * Only creating an anchored clock once per local trace ensures span times are correct relative
+ * to each other. For example, a child span will never have a start time before its parent even
+ * if the system clock is corrected during the local trace.
+ *
+ * Heavily inspired by the OTel Java anchored clock
+ * https://github.com/open-telemetry/opentelemetry-java/blob/main/sdk/trace/src/main/java/io/opentelemetry/sdk/trace/AnchoredClock.java
+ */
+ var AnchoredClock = class {
+ _monotonicClock;
+ _epochMillis;
+ _performanceMillis;
+ /**
+ * Create a new AnchoredClock anchored to the current time returned by systemClock.
+ *
+ * @param systemClock should be a clock that returns the number of milliseconds since January 1 1970 such as Date
+ * @param monotonicClock should be a clock that counts milliseconds monotonically such as window.performance or perf_hooks.performance
+ */
+ constructor(systemClock, monotonicClock) {
+ this._monotonicClock = monotonicClock;
+ this._epochMillis = systemClock.now();
+ this._performanceMillis = monotonicClock.now();
+ }
+ /**
+ * Returns the current time by adding the number of milliseconds since the
+ * AnchoredClock was created to the creation epoch time
+ */
+ now() {
+ const delta = this._monotonicClock.now() - this._performanceMillis;
+ return this._epochMillis + delta;
+ }
+ };
+ exports.AnchoredClock = AnchoredClock;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/common/attributes.js
+var require_attributes$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.isAttributeValue = exports.isAttributeKey = exports.sanitizeAttributes = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ function sanitizeAttributes(attributes) {
+ const out = {};
+ if (typeof attributes !== "object" || attributes == null) return out;
+ for (const [key, val] of Object.entries(attributes)) {
+ if (!isAttributeKey(key)) {
+ api_1.diag.warn(`Invalid attribute key: ${key}`);
+ continue;
+ }
+ if (!isAttributeValue(val)) {
+ api_1.diag.warn(`Invalid attribute value set for key: ${key}`);
+ continue;
+ }
+ if (Array.isArray(val)) out[key] = val.slice();
+ else out[key] = val;
+ }
+ return out;
+ }
+ exports.sanitizeAttributes = sanitizeAttributes;
+ function isAttributeKey(key) {
+ return typeof key === "string" && key.length > 0;
+ }
+ exports.isAttributeKey = isAttributeKey;
+ function isAttributeValue(val) {
+ if (val == null) return true;
+ if (Array.isArray(val)) return isHomogeneousAttributeValueArray(val);
+ return isValidPrimitiveAttributeValue(val);
+ }
+ exports.isAttributeValue = isAttributeValue;
+ function isHomogeneousAttributeValueArray(arr) {
+ let type;
+ for (const element of arr) {
+ if (element == null) continue;
+ if (!type) {
+ if (isValidPrimitiveAttributeValue(element)) {
+ type = typeof element;
+ continue;
+ }
+ return false;
+ }
+ if (typeof element === type) continue;
+ return false;
+ }
+ return true;
+ }
+ function isValidPrimitiveAttributeValue(val) {
+ switch (typeof val) {
+ case "number":
+ case "boolean":
+ case "string": return true;
+ }
+ return false;
+ }
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/common/logging-error-handler.js
+var require_logging_error_handler$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.loggingErrorHandler = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ /**
+ * Returns a function that logs an error using the provided logger, or a
+ * console logger if one was not provided.
+ */
+ function loggingErrorHandler() {
+ return (ex) => {
+ api_1.diag.error(stringifyException(ex));
+ };
+ }
+ exports.loggingErrorHandler = loggingErrorHandler;
+ /**
+ * Converts an exception into a string representation
+ * @param {Exception} ex
+ */
+ function stringifyException(ex) {
+ if (typeof ex === "string") return ex;
+ else return JSON.stringify(flattenException(ex));
+ }
+ /**
+ * Flattens an exception into key-value pairs by traversing the prototype chain
+ * and coercing values to strings. Duplicate properties will not be overwritten;
+ * the first insert wins.
+ */
+ function flattenException(ex) {
+ const result = {};
+ let current = ex;
+ while (current !== null) {
+ Object.getOwnPropertyNames(current).forEach((propertyName) => {
+ if (result[propertyName]) return;
+ const value = current[propertyName];
+ if (value) result[propertyName] = String(value);
+ });
+ current = Object.getPrototypeOf(current);
+ }
+ return result;
+ }
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/common/global-error-handler.js
+var require_global_error_handler$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.globalErrorHandler = exports.setGlobalErrorHandler = void 0;
+ /** The global error handler delegate */
+ let delegateHandler = (0, require_logging_error_handler$1().loggingErrorHandler)();
+ /**
+ * Set the global error handler
+ * @param {ErrorHandler} handler
+ */
+ function setGlobalErrorHandler(handler) {
+ delegateHandler = handler;
+ }
+ exports.setGlobalErrorHandler = setGlobalErrorHandler;
+ /**
+ * Return the global error handler
+ * @param {Exception} ex
+ */
+ function globalErrorHandler(ex) {
+ try {
+ delegateHandler(ex);
+ } catch {}
+ }
+ exports.globalErrorHandler = globalErrorHandler;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/platform/node/environment.js
+var require_environment$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.getStringListFromEnv = exports.getBooleanFromEnv = exports.getStringFromEnv = exports.getNumberFromEnv = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ const util_1$1 = __require("util");
+ /**
+ * Retrieves a number from an environment variable.
+ * - Returns `undefined` if the environment variable is empty, unset, contains only whitespace, or is not a number.
+ * - Returns a number in all other cases.
+ *
+ * @param {string} key - The name of the environment variable to retrieve.
+ * @returns {number | undefined} - The number value or `undefined`.
+ */
+ function getNumberFromEnv(key) {
+ const raw = process.env[key];
+ if (raw == null || raw.trim() === "") return;
+ const value = Number(raw);
+ if (isNaN(value)) {
+ api_1.diag.warn(`Unknown value ${(0, util_1$1.inspect)(raw)} for ${key}, expected a number, using defaults`);
+ return;
+ }
+ return value;
+ }
+ exports.getNumberFromEnv = getNumberFromEnv;
+ /**
+ * Retrieves a string from an environment variable.
+ * - Returns `undefined` if the environment variable is empty, unset, or contains only whitespace.
+ *
+ * @param {string} key - The name of the environment variable to retrieve.
+ * @returns {string | undefined} - The string value or `undefined`.
+ */
+ function getStringFromEnv(key) {
+ const raw = process.env[key];
+ if (raw == null || raw.trim() === "") return;
+ return raw;
+ }
+ exports.getStringFromEnv = getStringFromEnv;
+ /**
+ * Retrieves a boolean value from an environment variable.
+ * - Trims leading and trailing whitespace and ignores casing.
+ * - Returns `false` if the environment variable is empty, unset, or contains only whitespace.
+ * - Returns `false` for strings that cannot be mapped to a boolean.
+ *
+ * @param {string} key - The name of the environment variable to retrieve.
+ * @returns {boolean} - The boolean value or `false` if the environment variable is unset empty, unset, or contains only whitespace.
+ */
+ function getBooleanFromEnv(key) {
+ const raw = process.env[key]?.trim().toLowerCase();
+ if (raw == null || raw === "") return false;
+ if (raw === "true") return true;
+ else if (raw === "false") return false;
+ else {
+ api_1.diag.warn(`Unknown value ${(0, util_1$1.inspect)(raw)} for ${key}, expected 'true' or 'false', falling back to 'false' (default)`);
+ return false;
+ }
+ }
+ exports.getBooleanFromEnv = getBooleanFromEnv;
+ /**
+ * Retrieves a list of strings from an environment variable.
+ * - Uses ',' as the delimiter.
+ * - Trims leading and trailing whitespace from each entry.
+ * - Excludes empty entries.
+ * - Returns `undefined` if the environment variable is empty or contains only whitespace.
+ * - Returns an empty array if all entries are empty or whitespace.
+ *
+ * @param {string} key - The name of the environment variable to retrieve.
+ * @returns {string[] | undefined} - The list of strings or `undefined`.
+ */
+ function getStringListFromEnv(key) {
+ return getStringFromEnv(key)?.split(",").map((v) => v.trim()).filter((s) => s !== "");
+ }
+ exports.getStringListFromEnv = getStringListFromEnv;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/platform/node/globalThis.js
+var require_globalThis$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports._globalThis = void 0;
+ /** only globals that common to node and browsers are allowed */
+ exports._globalThis = typeof globalThis === "object" ? globalThis : global;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/platform/node/performance.js
+var require_performance = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.otperformance = void 0;
+ const perf_hooks_1 = __require("perf_hooks");
+ exports.otperformance = perf_hooks_1.performance;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/version.js
+var require_version$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.VERSION = void 0;
+ exports.VERSION = "2.1.0";
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/node_modules/@opentelemetry/semantic-conventions/build/esm/internal/utils.js
+/**
+* Creates a const map from the given values
+* @param values - An array of values to be used as keys and values in the map.
+* @returns A populated version of the map with the values and keys derived from the values.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function createConstMap(values) {
+ let res = {};
+ const len = values.length;
+ for (let lp = 0; lp < len; lp++) {
+ const val = values[lp];
+ if (val) res[String(val).toUpperCase().replace(/[-.]/g, "_")] = val;
+ }
+ return res;
+}
+var init_utils = __esmMin((() => {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/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 = __esmMin((() => {
+ init_utils();
+ 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]);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js
+var init_trace = __esmMin((() => {
+ init_SemanticAttributes();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/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 = __esmMin((() => {
+ init_utils();
+ 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
+ ]);
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js
+var init_resource = __esmMin((() => {
+ init_SemanticResourceAttributes();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
+var ATTR_ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT, ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_ABORTED, ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_HANDLED, ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_SKIPPED, ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_UNHANDLED, ATTR_ASPNETCORE_DIAGNOSTICS_HANDLER_TYPE, ATTR_ASPNETCORE_RATE_LIMITING_POLICY, ATTR_ASPNETCORE_RATE_LIMITING_RESULT, ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ACQUIRED, ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ENDPOINT_LIMITER, ASPNETCORE_RATE_LIMITING_RESULT_VALUE_GLOBAL_LIMITER, ASPNETCORE_RATE_LIMITING_RESULT_VALUE_REQUEST_CANCELED, ATTR_ASPNETCORE_REQUEST_IS_UNHANDLED, ATTR_ASPNETCORE_ROUTING_IS_FALLBACK, ATTR_ASPNETCORE_ROUTING_MATCH_STATUS, ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_FAILURE, ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_SUCCESS, ATTR_ASPNETCORE_USER_IS_AUTHENTICATED, ATTR_CLIENT_ADDRESS, ATTR_CLIENT_PORT, ATTR_CODE_COLUMN_NUMBER, ATTR_CODE_FILE_PATH, ATTR_CODE_FUNCTION_NAME, ATTR_CODE_LINE_NUMBER, ATTR_CODE_STACKTRACE, ATTR_DB_COLLECTION_NAME, ATTR_DB_NAMESPACE, ATTR_DB_OPERATION_BATCH_SIZE, ATTR_DB_OPERATION_NAME, ATTR_DB_QUERY_SUMMARY, ATTR_DB_QUERY_TEXT, ATTR_DB_RESPONSE_STATUS_CODE, ATTR_DB_STORED_PROCEDURE_NAME, ATTR_DB_SYSTEM_NAME, DB_SYSTEM_NAME_VALUE_MARIADB, DB_SYSTEM_NAME_VALUE_MICROSOFT_SQL_SERVER, DB_SYSTEM_NAME_VALUE_MYSQL, DB_SYSTEM_NAME_VALUE_POSTGRESQL, ATTR_DEPLOYMENT_ENVIRONMENT_NAME, DEPLOYMENT_ENVIRONMENT_NAME_VALUE_DEVELOPMENT, DEPLOYMENT_ENVIRONMENT_NAME_VALUE_PRODUCTION, DEPLOYMENT_ENVIRONMENT_NAME_VALUE_STAGING, DEPLOYMENT_ENVIRONMENT_NAME_VALUE_TEST, ATTR_DOTNET_GC_HEAP_GENERATION, DOTNET_GC_HEAP_GENERATION_VALUE_GEN0, DOTNET_GC_HEAP_GENERATION_VALUE_GEN1, DOTNET_GC_HEAP_GENERATION_VALUE_GEN2, DOTNET_GC_HEAP_GENERATION_VALUE_LOH, DOTNET_GC_HEAP_GENERATION_VALUE_POH, ATTR_ERROR_TYPE, ERROR_TYPE_VALUE_OTHER, ATTR_EXCEPTION_ESCAPED, ATTR_EXCEPTION_MESSAGE, ATTR_EXCEPTION_STACKTRACE, ATTR_EXCEPTION_TYPE, ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, HTTP_REQUEST_METHOD_VALUE_OTHER, HTTP_REQUEST_METHOD_VALUE_CONNECT, HTTP_REQUEST_METHOD_VALUE_DELETE, HTTP_REQUEST_METHOD_VALUE_GET, HTTP_REQUEST_METHOD_VALUE_HEAD, HTTP_REQUEST_METHOD_VALUE_OPTIONS, HTTP_REQUEST_METHOD_VALUE_PATCH, HTTP_REQUEST_METHOD_VALUE_POST, HTTP_REQUEST_METHOD_VALUE_PUT, HTTP_REQUEST_METHOD_VALUE_TRACE, ATTR_HTTP_REQUEST_METHOD_ORIGINAL, ATTR_HTTP_REQUEST_RESEND_COUNT, ATTR_HTTP_RESPONSE_HEADER, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_JVM_GC_ACTION, ATTR_JVM_GC_NAME, ATTR_JVM_MEMORY_POOL_NAME, ATTR_JVM_MEMORY_TYPE, JVM_MEMORY_TYPE_VALUE_HEAP, JVM_MEMORY_TYPE_VALUE_NON_HEAP, ATTR_JVM_THREAD_DAEMON, ATTR_JVM_THREAD_STATE, JVM_THREAD_STATE_VALUE_BLOCKED, JVM_THREAD_STATE_VALUE_NEW, JVM_THREAD_STATE_VALUE_RUNNABLE, JVM_THREAD_STATE_VALUE_TERMINATED, JVM_THREAD_STATE_VALUE_TIMED_WAITING, JVM_THREAD_STATE_VALUE_WAITING, ATTR_NETWORK_LOCAL_ADDRESS, ATTR_NETWORK_LOCAL_PORT, ATTR_NETWORK_PEER_ADDRESS, ATTR_NETWORK_PEER_PORT, ATTR_NETWORK_PROTOCOL_NAME, ATTR_NETWORK_PROTOCOL_VERSION, ATTR_NETWORK_TRANSPORT, NETWORK_TRANSPORT_VALUE_PIPE, NETWORK_TRANSPORT_VALUE_QUIC, NETWORK_TRANSPORT_VALUE_TCP, NETWORK_TRANSPORT_VALUE_UDP, NETWORK_TRANSPORT_VALUE_UNIX, ATTR_NETWORK_TYPE, NETWORK_TYPE_VALUE_IPV4, NETWORK_TYPE_VALUE_IPV6, ATTR_OTEL_EVENT_NAME, ATTR_OTEL_SCOPE_NAME, ATTR_OTEL_SCOPE_VERSION, ATTR_OTEL_STATUS_CODE, OTEL_STATUS_CODE_VALUE_ERROR, OTEL_STATUS_CODE_VALUE_OK, ATTR_OTEL_STATUS_DESCRIPTION, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_SERVICE_INSTANCE_ID, ATTR_SERVICE_NAME, ATTR_SERVICE_NAMESPACE, ATTR_SERVICE_VERSION, ATTR_SIGNALR_CONNECTION_STATUS, SIGNALR_CONNECTION_STATUS_VALUE_APP_SHUTDOWN, SIGNALR_CONNECTION_STATUS_VALUE_NORMAL_CLOSURE, SIGNALR_CONNECTION_STATUS_VALUE_TIMEOUT, ATTR_SIGNALR_TRANSPORT, SIGNALR_TRANSPORT_VALUE_LONG_POLLING, SIGNALR_TRANSPORT_VALUE_SERVER_SENT_EVENTS, SIGNALR_TRANSPORT_VALUE_WEB_SOCKETS, ATTR_TELEMETRY_DISTRO_NAME, ATTR_TELEMETRY_DISTRO_VERSION, ATTR_TELEMETRY_SDK_LANGUAGE, TELEMETRY_SDK_LANGUAGE_VALUE_CPP, TELEMETRY_SDK_LANGUAGE_VALUE_DOTNET, TELEMETRY_SDK_LANGUAGE_VALUE_ERLANG, TELEMETRY_SDK_LANGUAGE_VALUE_GO, TELEMETRY_SDK_LANGUAGE_VALUE_JAVA, TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS, TELEMETRY_SDK_LANGUAGE_VALUE_PHP, TELEMETRY_SDK_LANGUAGE_VALUE_PYTHON, TELEMETRY_SDK_LANGUAGE_VALUE_RUBY, TELEMETRY_SDK_LANGUAGE_VALUE_RUST, TELEMETRY_SDK_LANGUAGE_VALUE_SWIFT, TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS, ATTR_TELEMETRY_SDK_NAME, ATTR_TELEMETRY_SDK_VERSION, ATTR_URL_FRAGMENT, ATTR_URL_FULL, ATTR_URL_PATH, ATTR_URL_QUERY, ATTR_URL_SCHEME, ATTR_USER_AGENT_ORIGINAL;
+var init_stable_attributes = __esmMin((() => {
+ ATTR_ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT = "aspnetcore.diagnostics.exception.result";
+ ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_ABORTED = "aborted";
+ ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_HANDLED = "handled";
+ ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_SKIPPED = "skipped";
+ ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_UNHANDLED = "unhandled";
+ ATTR_ASPNETCORE_DIAGNOSTICS_HANDLER_TYPE = "aspnetcore.diagnostics.handler.type";
+ ATTR_ASPNETCORE_RATE_LIMITING_POLICY = "aspnetcore.rate_limiting.policy";
+ ATTR_ASPNETCORE_RATE_LIMITING_RESULT = "aspnetcore.rate_limiting.result";
+ ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ACQUIRED = "acquired";
+ ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ENDPOINT_LIMITER = "endpoint_limiter";
+ ASPNETCORE_RATE_LIMITING_RESULT_VALUE_GLOBAL_LIMITER = "global_limiter";
+ ASPNETCORE_RATE_LIMITING_RESULT_VALUE_REQUEST_CANCELED = "request_canceled";
+ ATTR_ASPNETCORE_REQUEST_IS_UNHANDLED = "aspnetcore.request.is_unhandled";
+ ATTR_ASPNETCORE_ROUTING_IS_FALLBACK = "aspnetcore.routing.is_fallback";
+ ATTR_ASPNETCORE_ROUTING_MATCH_STATUS = "aspnetcore.routing.match_status";
+ ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_FAILURE = "failure";
+ ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_SUCCESS = "success";
+ ATTR_ASPNETCORE_USER_IS_AUTHENTICATED = "aspnetcore.user.is_authenticated";
+ ATTR_CLIENT_ADDRESS = "client.address";
+ ATTR_CLIENT_PORT = "client.port";
+ ATTR_CODE_COLUMN_NUMBER = "code.column.number";
+ ATTR_CODE_FILE_PATH = "code.file.path";
+ ATTR_CODE_FUNCTION_NAME = "code.function.name";
+ ATTR_CODE_LINE_NUMBER = "code.line.number";
+ ATTR_CODE_STACKTRACE = "code.stacktrace";
+ ATTR_DB_COLLECTION_NAME = "db.collection.name";
+ ATTR_DB_NAMESPACE = "db.namespace";
+ ATTR_DB_OPERATION_BATCH_SIZE = "db.operation.batch.size";
+ ATTR_DB_OPERATION_NAME = "db.operation.name";
+ ATTR_DB_QUERY_SUMMARY = "db.query.summary";
+ ATTR_DB_QUERY_TEXT = "db.query.text";
+ ATTR_DB_RESPONSE_STATUS_CODE = "db.response.status_code";
+ ATTR_DB_STORED_PROCEDURE_NAME = "db.stored_procedure.name";
+ ATTR_DB_SYSTEM_NAME = "db.system.name";
+ DB_SYSTEM_NAME_VALUE_MARIADB = "mariadb";
+ DB_SYSTEM_NAME_VALUE_MICROSOFT_SQL_SERVER = "microsoft.sql_server";
+ DB_SYSTEM_NAME_VALUE_MYSQL = "mysql";
+ DB_SYSTEM_NAME_VALUE_POSTGRESQL = "postgresql";
+ ATTR_DEPLOYMENT_ENVIRONMENT_NAME = "deployment.environment.name";
+ DEPLOYMENT_ENVIRONMENT_NAME_VALUE_DEVELOPMENT = "development";
+ DEPLOYMENT_ENVIRONMENT_NAME_VALUE_PRODUCTION = "production";
+ DEPLOYMENT_ENVIRONMENT_NAME_VALUE_STAGING = "staging";
+ DEPLOYMENT_ENVIRONMENT_NAME_VALUE_TEST = "test";
+ ATTR_DOTNET_GC_HEAP_GENERATION = "dotnet.gc.heap.generation";
+ DOTNET_GC_HEAP_GENERATION_VALUE_GEN0 = "gen0";
+ DOTNET_GC_HEAP_GENERATION_VALUE_GEN1 = "gen1";
+ DOTNET_GC_HEAP_GENERATION_VALUE_GEN2 = "gen2";
+ DOTNET_GC_HEAP_GENERATION_VALUE_LOH = "loh";
+ DOTNET_GC_HEAP_GENERATION_VALUE_POH = "poh";
+ ATTR_ERROR_TYPE = "error.type";
+ ERROR_TYPE_VALUE_OTHER = "_OTHER";
+ ATTR_EXCEPTION_ESCAPED = "exception.escaped";
+ ATTR_EXCEPTION_MESSAGE = "exception.message";
+ ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace";
+ ATTR_EXCEPTION_TYPE = "exception.type";
+ ATTR_HTTP_REQUEST_HEADER = (key) => `http.request.header.${key}`;
+ ATTR_HTTP_REQUEST_METHOD = "http.request.method";
+ HTTP_REQUEST_METHOD_VALUE_OTHER = "_OTHER";
+ HTTP_REQUEST_METHOD_VALUE_CONNECT = "CONNECT";
+ HTTP_REQUEST_METHOD_VALUE_DELETE = "DELETE";
+ HTTP_REQUEST_METHOD_VALUE_GET = "GET";
+ HTTP_REQUEST_METHOD_VALUE_HEAD = "HEAD";
+ HTTP_REQUEST_METHOD_VALUE_OPTIONS = "OPTIONS";
+ HTTP_REQUEST_METHOD_VALUE_PATCH = "PATCH";
+ HTTP_REQUEST_METHOD_VALUE_POST = "POST";
+ HTTP_REQUEST_METHOD_VALUE_PUT = "PUT";
+ HTTP_REQUEST_METHOD_VALUE_TRACE = "TRACE";
+ ATTR_HTTP_REQUEST_METHOD_ORIGINAL = "http.request.method_original";
+ ATTR_HTTP_REQUEST_RESEND_COUNT = "http.request.resend_count";
+ ATTR_HTTP_RESPONSE_HEADER = (key) => `http.response.header.${key}`;
+ ATTR_HTTP_RESPONSE_STATUS_CODE = "http.response.status_code";
+ ATTR_HTTP_ROUTE = "http.route";
+ ATTR_JVM_GC_ACTION = "jvm.gc.action";
+ ATTR_JVM_GC_NAME = "jvm.gc.name";
+ ATTR_JVM_MEMORY_POOL_NAME = "jvm.memory.pool.name";
+ ATTR_JVM_MEMORY_TYPE = "jvm.memory.type";
+ JVM_MEMORY_TYPE_VALUE_HEAP = "heap";
+ JVM_MEMORY_TYPE_VALUE_NON_HEAP = "non_heap";
+ ATTR_JVM_THREAD_DAEMON = "jvm.thread.daemon";
+ ATTR_JVM_THREAD_STATE = "jvm.thread.state";
+ JVM_THREAD_STATE_VALUE_BLOCKED = "blocked";
+ JVM_THREAD_STATE_VALUE_NEW = "new";
+ JVM_THREAD_STATE_VALUE_RUNNABLE = "runnable";
+ JVM_THREAD_STATE_VALUE_TERMINATED = "terminated";
+ JVM_THREAD_STATE_VALUE_TIMED_WAITING = "timed_waiting";
+ JVM_THREAD_STATE_VALUE_WAITING = "waiting";
+ ATTR_NETWORK_LOCAL_ADDRESS = "network.local.address";
+ ATTR_NETWORK_LOCAL_PORT = "network.local.port";
+ ATTR_NETWORK_PEER_ADDRESS = "network.peer.address";
+ ATTR_NETWORK_PEER_PORT = "network.peer.port";
+ ATTR_NETWORK_PROTOCOL_NAME = "network.protocol.name";
+ ATTR_NETWORK_PROTOCOL_VERSION = "network.protocol.version";
+ ATTR_NETWORK_TRANSPORT = "network.transport";
+ NETWORK_TRANSPORT_VALUE_PIPE = "pipe";
+ NETWORK_TRANSPORT_VALUE_QUIC = "quic";
+ NETWORK_TRANSPORT_VALUE_TCP = "tcp";
+ NETWORK_TRANSPORT_VALUE_UDP = "udp";
+ NETWORK_TRANSPORT_VALUE_UNIX = "unix";
+ ATTR_NETWORK_TYPE = "network.type";
+ NETWORK_TYPE_VALUE_IPV4 = "ipv4";
+ NETWORK_TYPE_VALUE_IPV6 = "ipv6";
+ ATTR_OTEL_EVENT_NAME = "otel.event.name";
+ ATTR_OTEL_SCOPE_NAME = "otel.scope.name";
+ ATTR_OTEL_SCOPE_VERSION = "otel.scope.version";
+ ATTR_OTEL_STATUS_CODE = "otel.status_code";
+ OTEL_STATUS_CODE_VALUE_ERROR = "ERROR";
+ OTEL_STATUS_CODE_VALUE_OK = "OK";
+ ATTR_OTEL_STATUS_DESCRIPTION = "otel.status_description";
+ ATTR_SERVER_ADDRESS = "server.address";
+ ATTR_SERVER_PORT = "server.port";
+ ATTR_SERVICE_INSTANCE_ID = "service.instance.id";
+ ATTR_SERVICE_NAME = "service.name";
+ ATTR_SERVICE_NAMESPACE = "service.namespace";
+ ATTR_SERVICE_VERSION = "service.version";
+ ATTR_SIGNALR_CONNECTION_STATUS = "signalr.connection.status";
+ SIGNALR_CONNECTION_STATUS_VALUE_APP_SHUTDOWN = "app_shutdown";
+ SIGNALR_CONNECTION_STATUS_VALUE_NORMAL_CLOSURE = "normal_closure";
+ SIGNALR_CONNECTION_STATUS_VALUE_TIMEOUT = "timeout";
+ ATTR_SIGNALR_TRANSPORT = "signalr.transport";
+ SIGNALR_TRANSPORT_VALUE_LONG_POLLING = "long_polling";
+ SIGNALR_TRANSPORT_VALUE_SERVER_SENT_EVENTS = "server_sent_events";
+ SIGNALR_TRANSPORT_VALUE_WEB_SOCKETS = "web_sockets";
+ ATTR_TELEMETRY_DISTRO_NAME = "telemetry.distro.name";
+ ATTR_TELEMETRY_DISTRO_VERSION = "telemetry.distro.version";
+ ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
+ TELEMETRY_SDK_LANGUAGE_VALUE_CPP = "cpp";
+ TELEMETRY_SDK_LANGUAGE_VALUE_DOTNET = "dotnet";
+ TELEMETRY_SDK_LANGUAGE_VALUE_ERLANG = "erlang";
+ TELEMETRY_SDK_LANGUAGE_VALUE_GO = "go";
+ TELEMETRY_SDK_LANGUAGE_VALUE_JAVA = "java";
+ TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS = "nodejs";
+ TELEMETRY_SDK_LANGUAGE_VALUE_PHP = "php";
+ TELEMETRY_SDK_LANGUAGE_VALUE_PYTHON = "python";
+ TELEMETRY_SDK_LANGUAGE_VALUE_RUBY = "ruby";
+ TELEMETRY_SDK_LANGUAGE_VALUE_RUST = "rust";
+ TELEMETRY_SDK_LANGUAGE_VALUE_SWIFT = "swift";
+ TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS = "webjs";
+ ATTR_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
+ ATTR_TELEMETRY_SDK_VERSION = "telemetry.sdk.version";
+ ATTR_URL_FRAGMENT = "url.fragment";
+ ATTR_URL_FULL = "url.full";
+ ATTR_URL_PATH = "url.path";
+ ATTR_URL_QUERY = "url.query";
+ ATTR_URL_SCHEME = "url.scheme";
+ ATTR_USER_AGENT_ORIGINAL = "user_agent.original";
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_metrics.js
+var METRIC_ASPNETCORE_DIAGNOSTICS_EXCEPTIONS, METRIC_ASPNETCORE_RATE_LIMITING_ACTIVE_REQUEST_LEASES, METRIC_ASPNETCORE_RATE_LIMITING_QUEUED_REQUESTS, METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_TIME_IN_QUEUE, METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_LEASE_DURATION, METRIC_ASPNETCORE_RATE_LIMITING_REQUESTS, METRIC_ASPNETCORE_ROUTING_MATCH_ATTEMPTS, METRIC_DB_CLIENT_OPERATION_DURATION, METRIC_DOTNET_ASSEMBLY_COUNT, METRIC_DOTNET_EXCEPTIONS, METRIC_DOTNET_GC_COLLECTIONS, METRIC_DOTNET_GC_HEAP_TOTAL_ALLOCATED, METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_FRAGMENTATION_SIZE, METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_SIZE, METRIC_DOTNET_GC_LAST_COLLECTION_MEMORY_COMMITTED_SIZE, METRIC_DOTNET_GC_PAUSE_TIME, METRIC_DOTNET_JIT_COMPILATION_TIME, METRIC_DOTNET_JIT_COMPILED_IL_SIZE, METRIC_DOTNET_JIT_COMPILED_METHODS, METRIC_DOTNET_MONITOR_LOCK_CONTENTIONS, METRIC_DOTNET_PROCESS_CPU_COUNT, METRIC_DOTNET_PROCESS_CPU_TIME, METRIC_DOTNET_PROCESS_MEMORY_WORKING_SET, METRIC_DOTNET_THREAD_POOL_QUEUE_LENGTH, METRIC_DOTNET_THREAD_POOL_THREAD_COUNT, METRIC_DOTNET_THREAD_POOL_WORK_ITEM_COUNT, METRIC_DOTNET_TIMER_COUNT, METRIC_HTTP_CLIENT_REQUEST_DURATION, METRIC_HTTP_SERVER_REQUEST_DURATION, METRIC_JVM_CLASS_COUNT, METRIC_JVM_CLASS_LOADED, METRIC_JVM_CLASS_UNLOADED, METRIC_JVM_CPU_COUNT, METRIC_JVM_CPU_RECENT_UTILIZATION, METRIC_JVM_CPU_TIME, METRIC_JVM_GC_DURATION, METRIC_JVM_MEMORY_COMMITTED, METRIC_JVM_MEMORY_LIMIT, METRIC_JVM_MEMORY_USED, METRIC_JVM_MEMORY_USED_AFTER_LAST_GC, METRIC_JVM_THREAD_COUNT, METRIC_KESTREL_ACTIVE_CONNECTIONS, METRIC_KESTREL_ACTIVE_TLS_HANDSHAKES, METRIC_KESTREL_CONNECTION_DURATION, METRIC_KESTREL_QUEUED_CONNECTIONS, METRIC_KESTREL_QUEUED_REQUESTS, METRIC_KESTREL_REJECTED_CONNECTIONS, METRIC_KESTREL_TLS_HANDSHAKE_DURATION, METRIC_KESTREL_UPGRADED_CONNECTIONS, METRIC_SIGNALR_SERVER_ACTIVE_CONNECTIONS, METRIC_SIGNALR_SERVER_CONNECTION_DURATION;
+var init_stable_metrics = __esmMin((() => {
+ METRIC_ASPNETCORE_DIAGNOSTICS_EXCEPTIONS = "aspnetcore.diagnostics.exceptions";
+ METRIC_ASPNETCORE_RATE_LIMITING_ACTIVE_REQUEST_LEASES = "aspnetcore.rate_limiting.active_request_leases";
+ METRIC_ASPNETCORE_RATE_LIMITING_QUEUED_REQUESTS = "aspnetcore.rate_limiting.queued_requests";
+ METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_TIME_IN_QUEUE = "aspnetcore.rate_limiting.request.time_in_queue";
+ METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_LEASE_DURATION = "aspnetcore.rate_limiting.request_lease.duration";
+ METRIC_ASPNETCORE_RATE_LIMITING_REQUESTS = "aspnetcore.rate_limiting.requests";
+ METRIC_ASPNETCORE_ROUTING_MATCH_ATTEMPTS = "aspnetcore.routing.match_attempts";
+ METRIC_DB_CLIENT_OPERATION_DURATION = "db.client.operation.duration";
+ METRIC_DOTNET_ASSEMBLY_COUNT = "dotnet.assembly.count";
+ METRIC_DOTNET_EXCEPTIONS = "dotnet.exceptions";
+ METRIC_DOTNET_GC_COLLECTIONS = "dotnet.gc.collections";
+ METRIC_DOTNET_GC_HEAP_TOTAL_ALLOCATED = "dotnet.gc.heap.total_allocated";
+ METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_FRAGMENTATION_SIZE = "dotnet.gc.last_collection.heap.fragmentation.size";
+ METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_SIZE = "dotnet.gc.last_collection.heap.size";
+ METRIC_DOTNET_GC_LAST_COLLECTION_MEMORY_COMMITTED_SIZE = "dotnet.gc.last_collection.memory.committed_size";
+ METRIC_DOTNET_GC_PAUSE_TIME = "dotnet.gc.pause.time";
+ METRIC_DOTNET_JIT_COMPILATION_TIME = "dotnet.jit.compilation.time";
+ METRIC_DOTNET_JIT_COMPILED_IL_SIZE = "dotnet.jit.compiled_il.size";
+ METRIC_DOTNET_JIT_COMPILED_METHODS = "dotnet.jit.compiled_methods";
+ METRIC_DOTNET_MONITOR_LOCK_CONTENTIONS = "dotnet.monitor.lock_contentions";
+ METRIC_DOTNET_PROCESS_CPU_COUNT = "dotnet.process.cpu.count";
+ METRIC_DOTNET_PROCESS_CPU_TIME = "dotnet.process.cpu.time";
+ METRIC_DOTNET_PROCESS_MEMORY_WORKING_SET = "dotnet.process.memory.working_set";
+ METRIC_DOTNET_THREAD_POOL_QUEUE_LENGTH = "dotnet.thread_pool.queue.length";
+ METRIC_DOTNET_THREAD_POOL_THREAD_COUNT = "dotnet.thread_pool.thread.count";
+ METRIC_DOTNET_THREAD_POOL_WORK_ITEM_COUNT = "dotnet.thread_pool.work_item.count";
+ METRIC_DOTNET_TIMER_COUNT = "dotnet.timer.count";
+ METRIC_HTTP_CLIENT_REQUEST_DURATION = "http.client.request.duration";
+ METRIC_HTTP_SERVER_REQUEST_DURATION = "http.server.request.duration";
+ METRIC_JVM_CLASS_COUNT = "jvm.class.count";
+ METRIC_JVM_CLASS_LOADED = "jvm.class.loaded";
+ METRIC_JVM_CLASS_UNLOADED = "jvm.class.unloaded";
+ METRIC_JVM_CPU_COUNT = "jvm.cpu.count";
+ METRIC_JVM_CPU_RECENT_UTILIZATION = "jvm.cpu.recent_utilization";
+ METRIC_JVM_CPU_TIME = "jvm.cpu.time";
+ METRIC_JVM_GC_DURATION = "jvm.gc.duration";
+ METRIC_JVM_MEMORY_COMMITTED = "jvm.memory.committed";
+ METRIC_JVM_MEMORY_LIMIT = "jvm.memory.limit";
+ METRIC_JVM_MEMORY_USED = "jvm.memory.used";
+ METRIC_JVM_MEMORY_USED_AFTER_LAST_GC = "jvm.memory.used_after_last_gc";
+ METRIC_JVM_THREAD_COUNT = "jvm.thread.count";
+ METRIC_KESTREL_ACTIVE_CONNECTIONS = "kestrel.active_connections";
+ METRIC_KESTREL_ACTIVE_TLS_HANDSHAKES = "kestrel.active_tls_handshakes";
+ METRIC_KESTREL_CONNECTION_DURATION = "kestrel.connection.duration";
+ METRIC_KESTREL_QUEUED_CONNECTIONS = "kestrel.queued_connections";
+ METRIC_KESTREL_QUEUED_REQUESTS = "kestrel.queued_requests";
+ METRIC_KESTREL_REJECTED_CONNECTIONS = "kestrel.rejected_connections";
+ METRIC_KESTREL_TLS_HANDSHAKE_DURATION = "kestrel.tls_handshake.duration";
+ METRIC_KESTREL_UPGRADED_CONNECTIONS = "kestrel.upgraded_connections";
+ METRIC_SIGNALR_SERVER_ACTIVE_CONNECTIONS = "signalr.server.active_connections";
+ METRIC_SIGNALR_SERVER_CONNECTION_DURATION = "signalr.server.connection.duration";
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_events.js
+var EVENT_EXCEPTION;
+var init_stable_events = __esmMin((() => {
+ EVENT_EXCEPTION = "exception";
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.41.1/node_modules/@opentelemetry/semantic-conventions/build/esm/index.js
+var esm_exports$1 = /* @__PURE__ */ __exportAll({
+ ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_ABORTED: () => ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_ABORTED,
+ ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_HANDLED: () => ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_HANDLED,
+ ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_SKIPPED: () => ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_SKIPPED,
+ ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_UNHANDLED: () => ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_UNHANDLED,
+ ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ACQUIRED: () => ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ACQUIRED,
+ ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ENDPOINT_LIMITER: () => ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ENDPOINT_LIMITER,
+ ASPNETCORE_RATE_LIMITING_RESULT_VALUE_GLOBAL_LIMITER: () => ASPNETCORE_RATE_LIMITING_RESULT_VALUE_GLOBAL_LIMITER,
+ ASPNETCORE_RATE_LIMITING_RESULT_VALUE_REQUEST_CANCELED: () => ASPNETCORE_RATE_LIMITING_RESULT_VALUE_REQUEST_CANCELED,
+ ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_FAILURE: () => ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_FAILURE,
+ ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_SUCCESS: () => ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_SUCCESS,
+ ATTR_ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT: () => ATTR_ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT,
+ ATTR_ASPNETCORE_DIAGNOSTICS_HANDLER_TYPE: () => ATTR_ASPNETCORE_DIAGNOSTICS_HANDLER_TYPE,
+ ATTR_ASPNETCORE_RATE_LIMITING_POLICY: () => ATTR_ASPNETCORE_RATE_LIMITING_POLICY,
+ ATTR_ASPNETCORE_RATE_LIMITING_RESULT: () => ATTR_ASPNETCORE_RATE_LIMITING_RESULT,
+ ATTR_ASPNETCORE_REQUEST_IS_UNHANDLED: () => ATTR_ASPNETCORE_REQUEST_IS_UNHANDLED,
+ ATTR_ASPNETCORE_ROUTING_IS_FALLBACK: () => ATTR_ASPNETCORE_ROUTING_IS_FALLBACK,
+ ATTR_ASPNETCORE_ROUTING_MATCH_STATUS: () => ATTR_ASPNETCORE_ROUTING_MATCH_STATUS,
+ ATTR_ASPNETCORE_USER_IS_AUTHENTICATED: () => ATTR_ASPNETCORE_USER_IS_AUTHENTICATED,
+ ATTR_CLIENT_ADDRESS: () => ATTR_CLIENT_ADDRESS,
+ ATTR_CLIENT_PORT: () => ATTR_CLIENT_PORT,
+ ATTR_CODE_COLUMN_NUMBER: () => ATTR_CODE_COLUMN_NUMBER,
+ ATTR_CODE_FILE_PATH: () => ATTR_CODE_FILE_PATH,
+ ATTR_CODE_FUNCTION_NAME: () => ATTR_CODE_FUNCTION_NAME,
+ ATTR_CODE_LINE_NUMBER: () => ATTR_CODE_LINE_NUMBER,
+ ATTR_CODE_STACKTRACE: () => ATTR_CODE_STACKTRACE,
+ ATTR_DB_COLLECTION_NAME: () => ATTR_DB_COLLECTION_NAME,
+ ATTR_DB_NAMESPACE: () => ATTR_DB_NAMESPACE,
+ ATTR_DB_OPERATION_BATCH_SIZE: () => ATTR_DB_OPERATION_BATCH_SIZE,
+ ATTR_DB_OPERATION_NAME: () => ATTR_DB_OPERATION_NAME,
+ ATTR_DB_QUERY_SUMMARY: () => ATTR_DB_QUERY_SUMMARY,
+ ATTR_DB_QUERY_TEXT: () => ATTR_DB_QUERY_TEXT,
+ ATTR_DB_RESPONSE_STATUS_CODE: () => ATTR_DB_RESPONSE_STATUS_CODE,
+ ATTR_DB_STORED_PROCEDURE_NAME: () => ATTR_DB_STORED_PROCEDURE_NAME,
+ ATTR_DB_SYSTEM_NAME: () => ATTR_DB_SYSTEM_NAME,
+ ATTR_DEPLOYMENT_ENVIRONMENT_NAME: () => ATTR_DEPLOYMENT_ENVIRONMENT_NAME,
+ ATTR_DOTNET_GC_HEAP_GENERATION: () => ATTR_DOTNET_GC_HEAP_GENERATION,
+ ATTR_ERROR_TYPE: () => ATTR_ERROR_TYPE,
+ ATTR_EXCEPTION_ESCAPED: () => ATTR_EXCEPTION_ESCAPED,
+ ATTR_EXCEPTION_MESSAGE: () => ATTR_EXCEPTION_MESSAGE,
+ ATTR_EXCEPTION_STACKTRACE: () => ATTR_EXCEPTION_STACKTRACE,
+ ATTR_EXCEPTION_TYPE: () => ATTR_EXCEPTION_TYPE,
+ ATTR_HTTP_REQUEST_HEADER: () => ATTR_HTTP_REQUEST_HEADER,
+ ATTR_HTTP_REQUEST_METHOD: () => ATTR_HTTP_REQUEST_METHOD,
+ ATTR_HTTP_REQUEST_METHOD_ORIGINAL: () => ATTR_HTTP_REQUEST_METHOD_ORIGINAL,
+ ATTR_HTTP_REQUEST_RESEND_COUNT: () => ATTR_HTTP_REQUEST_RESEND_COUNT,
+ ATTR_HTTP_RESPONSE_HEADER: () => ATTR_HTTP_RESPONSE_HEADER,
+ ATTR_HTTP_RESPONSE_STATUS_CODE: () => ATTR_HTTP_RESPONSE_STATUS_CODE,
+ ATTR_HTTP_ROUTE: () => ATTR_HTTP_ROUTE,
+ ATTR_JVM_GC_ACTION: () => ATTR_JVM_GC_ACTION,
+ ATTR_JVM_GC_NAME: () => ATTR_JVM_GC_NAME,
+ ATTR_JVM_MEMORY_POOL_NAME: () => ATTR_JVM_MEMORY_POOL_NAME,
+ ATTR_JVM_MEMORY_TYPE: () => ATTR_JVM_MEMORY_TYPE,
+ ATTR_JVM_THREAD_DAEMON: () => ATTR_JVM_THREAD_DAEMON,
+ ATTR_JVM_THREAD_STATE: () => ATTR_JVM_THREAD_STATE,
+ ATTR_NETWORK_LOCAL_ADDRESS: () => ATTR_NETWORK_LOCAL_ADDRESS,
+ ATTR_NETWORK_LOCAL_PORT: () => ATTR_NETWORK_LOCAL_PORT,
+ ATTR_NETWORK_PEER_ADDRESS: () => ATTR_NETWORK_PEER_ADDRESS,
+ ATTR_NETWORK_PEER_PORT: () => ATTR_NETWORK_PEER_PORT,
+ ATTR_NETWORK_PROTOCOL_NAME: () => ATTR_NETWORK_PROTOCOL_NAME,
+ ATTR_NETWORK_PROTOCOL_VERSION: () => ATTR_NETWORK_PROTOCOL_VERSION,
+ ATTR_NETWORK_TRANSPORT: () => ATTR_NETWORK_TRANSPORT,
+ ATTR_NETWORK_TYPE: () => ATTR_NETWORK_TYPE,
+ ATTR_OTEL_EVENT_NAME: () => ATTR_OTEL_EVENT_NAME,
+ ATTR_OTEL_SCOPE_NAME: () => ATTR_OTEL_SCOPE_NAME,
+ ATTR_OTEL_SCOPE_VERSION: () => ATTR_OTEL_SCOPE_VERSION,
+ ATTR_OTEL_STATUS_CODE: () => ATTR_OTEL_STATUS_CODE,
+ ATTR_OTEL_STATUS_DESCRIPTION: () => ATTR_OTEL_STATUS_DESCRIPTION,
+ ATTR_SERVER_ADDRESS: () => ATTR_SERVER_ADDRESS,
+ ATTR_SERVER_PORT: () => ATTR_SERVER_PORT,
+ ATTR_SERVICE_INSTANCE_ID: () => ATTR_SERVICE_INSTANCE_ID,
+ ATTR_SERVICE_NAME: () => ATTR_SERVICE_NAME,
+ ATTR_SERVICE_NAMESPACE: () => ATTR_SERVICE_NAMESPACE,
+ ATTR_SERVICE_VERSION: () => ATTR_SERVICE_VERSION,
+ ATTR_SIGNALR_CONNECTION_STATUS: () => ATTR_SIGNALR_CONNECTION_STATUS,
+ ATTR_SIGNALR_TRANSPORT: () => ATTR_SIGNALR_TRANSPORT,
+ ATTR_TELEMETRY_DISTRO_NAME: () => ATTR_TELEMETRY_DISTRO_NAME,
+ ATTR_TELEMETRY_DISTRO_VERSION: () => ATTR_TELEMETRY_DISTRO_VERSION,
+ ATTR_TELEMETRY_SDK_LANGUAGE: () => ATTR_TELEMETRY_SDK_LANGUAGE,
+ ATTR_TELEMETRY_SDK_NAME: () => ATTR_TELEMETRY_SDK_NAME,
+ ATTR_TELEMETRY_SDK_VERSION: () => ATTR_TELEMETRY_SDK_VERSION,
+ ATTR_URL_FRAGMENT: () => ATTR_URL_FRAGMENT,
+ ATTR_URL_FULL: () => ATTR_URL_FULL,
+ ATTR_URL_PATH: () => ATTR_URL_PATH,
+ ATTR_URL_QUERY: () => ATTR_URL_QUERY,
+ ATTR_URL_SCHEME: () => ATTR_URL_SCHEME,
+ ATTR_USER_AGENT_ORIGINAL: () => ATTR_USER_AGENT_ORIGINAL,
+ 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,
+ DB_SYSTEM_NAME_VALUE_MARIADB: () => DB_SYSTEM_NAME_VALUE_MARIADB,
+ DB_SYSTEM_NAME_VALUE_MICROSOFT_SQL_SERVER: () => DB_SYSTEM_NAME_VALUE_MICROSOFT_SQL_SERVER,
+ DB_SYSTEM_NAME_VALUE_MYSQL: () => DB_SYSTEM_NAME_VALUE_MYSQL,
+ DB_SYSTEM_NAME_VALUE_POSTGRESQL: () => DB_SYSTEM_NAME_VALUE_POSTGRESQL,
+ DEPLOYMENT_ENVIRONMENT_NAME_VALUE_DEVELOPMENT: () => DEPLOYMENT_ENVIRONMENT_NAME_VALUE_DEVELOPMENT,
+ DEPLOYMENT_ENVIRONMENT_NAME_VALUE_PRODUCTION: () => DEPLOYMENT_ENVIRONMENT_NAME_VALUE_PRODUCTION,
+ DEPLOYMENT_ENVIRONMENT_NAME_VALUE_STAGING: () => DEPLOYMENT_ENVIRONMENT_NAME_VALUE_STAGING,
+ DEPLOYMENT_ENVIRONMENT_NAME_VALUE_TEST: () => DEPLOYMENT_ENVIRONMENT_NAME_VALUE_TEST,
+ DOTNET_GC_HEAP_GENERATION_VALUE_GEN0: () => DOTNET_GC_HEAP_GENERATION_VALUE_GEN0,
+ DOTNET_GC_HEAP_GENERATION_VALUE_GEN1: () => DOTNET_GC_HEAP_GENERATION_VALUE_GEN1,
+ DOTNET_GC_HEAP_GENERATION_VALUE_GEN2: () => DOTNET_GC_HEAP_GENERATION_VALUE_GEN2,
+ DOTNET_GC_HEAP_GENERATION_VALUE_LOH: () => DOTNET_GC_HEAP_GENERATION_VALUE_LOH,
+ DOTNET_GC_HEAP_GENERATION_VALUE_POH: () => DOTNET_GC_HEAP_GENERATION_VALUE_POH,
+ DbCassandraConsistencyLevelValues: () => DbCassandraConsistencyLevelValues,
+ DbSystemValues: () => DbSystemValues,
+ ERROR_TYPE_VALUE_OTHER: () => ERROR_TYPE_VALUE_OTHER,
+ EVENT_EXCEPTION: () => EVENT_EXCEPTION,
+ 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,
+ HTTP_REQUEST_METHOD_VALUE_CONNECT: () => HTTP_REQUEST_METHOD_VALUE_CONNECT,
+ HTTP_REQUEST_METHOD_VALUE_DELETE: () => HTTP_REQUEST_METHOD_VALUE_DELETE,
+ HTTP_REQUEST_METHOD_VALUE_GET: () => HTTP_REQUEST_METHOD_VALUE_GET,
+ HTTP_REQUEST_METHOD_VALUE_HEAD: () => HTTP_REQUEST_METHOD_VALUE_HEAD,
+ HTTP_REQUEST_METHOD_VALUE_OPTIONS: () => HTTP_REQUEST_METHOD_VALUE_OPTIONS,
+ HTTP_REQUEST_METHOD_VALUE_OTHER: () => HTTP_REQUEST_METHOD_VALUE_OTHER,
+ HTTP_REQUEST_METHOD_VALUE_PATCH: () => HTTP_REQUEST_METHOD_VALUE_PATCH,
+ HTTP_REQUEST_METHOD_VALUE_POST: () => HTTP_REQUEST_METHOD_VALUE_POST,
+ HTTP_REQUEST_METHOD_VALUE_PUT: () => HTTP_REQUEST_METHOD_VALUE_PUT,
+ HTTP_REQUEST_METHOD_VALUE_TRACE: () => HTTP_REQUEST_METHOD_VALUE_TRACE,
+ HostArchValues: () => HostArchValues,
+ HttpFlavorValues: () => HttpFlavorValues,
+ JVM_MEMORY_TYPE_VALUE_HEAP: () => JVM_MEMORY_TYPE_VALUE_HEAP,
+ JVM_MEMORY_TYPE_VALUE_NON_HEAP: () => JVM_MEMORY_TYPE_VALUE_NON_HEAP,
+ JVM_THREAD_STATE_VALUE_BLOCKED: () => JVM_THREAD_STATE_VALUE_BLOCKED,
+ JVM_THREAD_STATE_VALUE_NEW: () => JVM_THREAD_STATE_VALUE_NEW,
+ JVM_THREAD_STATE_VALUE_RUNNABLE: () => JVM_THREAD_STATE_VALUE_RUNNABLE,
+ JVM_THREAD_STATE_VALUE_TERMINATED: () => JVM_THREAD_STATE_VALUE_TERMINATED,
+ JVM_THREAD_STATE_VALUE_TIMED_WAITING: () => JVM_THREAD_STATE_VALUE_TIMED_WAITING,
+ JVM_THREAD_STATE_VALUE_WAITING: () => JVM_THREAD_STATE_VALUE_WAITING,
+ MESSAGETYPEVALUES_RECEIVED: () => MESSAGETYPEVALUES_RECEIVED,
+ MESSAGETYPEVALUES_SENT: () => MESSAGETYPEVALUES_SENT,
+ MESSAGINGDESTINATIONKINDVALUES_QUEUE: () => MESSAGINGDESTINATIONKINDVALUES_QUEUE,
+ MESSAGINGDESTINATIONKINDVALUES_TOPIC: () => MESSAGINGDESTINATIONKINDVALUES_TOPIC,
+ MESSAGINGOPERATIONVALUES_PROCESS: () => MESSAGINGOPERATIONVALUES_PROCESS,
+ MESSAGINGOPERATIONVALUES_RECEIVE: () => MESSAGINGOPERATIONVALUES_RECEIVE,
+ METRIC_ASPNETCORE_DIAGNOSTICS_EXCEPTIONS: () => METRIC_ASPNETCORE_DIAGNOSTICS_EXCEPTIONS,
+ METRIC_ASPNETCORE_RATE_LIMITING_ACTIVE_REQUEST_LEASES: () => METRIC_ASPNETCORE_RATE_LIMITING_ACTIVE_REQUEST_LEASES,
+ METRIC_ASPNETCORE_RATE_LIMITING_QUEUED_REQUESTS: () => METRIC_ASPNETCORE_RATE_LIMITING_QUEUED_REQUESTS,
+ METRIC_ASPNETCORE_RATE_LIMITING_REQUESTS: () => METRIC_ASPNETCORE_RATE_LIMITING_REQUESTS,
+ METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_LEASE_DURATION: () => METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_LEASE_DURATION,
+ METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_TIME_IN_QUEUE: () => METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_TIME_IN_QUEUE,
+ METRIC_ASPNETCORE_ROUTING_MATCH_ATTEMPTS: () => METRIC_ASPNETCORE_ROUTING_MATCH_ATTEMPTS,
+ METRIC_DB_CLIENT_OPERATION_DURATION: () => METRIC_DB_CLIENT_OPERATION_DURATION,
+ METRIC_DOTNET_ASSEMBLY_COUNT: () => METRIC_DOTNET_ASSEMBLY_COUNT,
+ METRIC_DOTNET_EXCEPTIONS: () => METRIC_DOTNET_EXCEPTIONS,
+ METRIC_DOTNET_GC_COLLECTIONS: () => METRIC_DOTNET_GC_COLLECTIONS,
+ METRIC_DOTNET_GC_HEAP_TOTAL_ALLOCATED: () => METRIC_DOTNET_GC_HEAP_TOTAL_ALLOCATED,
+ METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_FRAGMENTATION_SIZE: () => METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_FRAGMENTATION_SIZE,
+ METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_SIZE: () => METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_SIZE,
+ METRIC_DOTNET_GC_LAST_COLLECTION_MEMORY_COMMITTED_SIZE: () => METRIC_DOTNET_GC_LAST_COLLECTION_MEMORY_COMMITTED_SIZE,
+ METRIC_DOTNET_GC_PAUSE_TIME: () => METRIC_DOTNET_GC_PAUSE_TIME,
+ METRIC_DOTNET_JIT_COMPILATION_TIME: () => METRIC_DOTNET_JIT_COMPILATION_TIME,
+ METRIC_DOTNET_JIT_COMPILED_IL_SIZE: () => METRIC_DOTNET_JIT_COMPILED_IL_SIZE,
+ METRIC_DOTNET_JIT_COMPILED_METHODS: () => METRIC_DOTNET_JIT_COMPILED_METHODS,
+ METRIC_DOTNET_MONITOR_LOCK_CONTENTIONS: () => METRIC_DOTNET_MONITOR_LOCK_CONTENTIONS,
+ METRIC_DOTNET_PROCESS_CPU_COUNT: () => METRIC_DOTNET_PROCESS_CPU_COUNT,
+ METRIC_DOTNET_PROCESS_CPU_TIME: () => METRIC_DOTNET_PROCESS_CPU_TIME,
+ METRIC_DOTNET_PROCESS_MEMORY_WORKING_SET: () => METRIC_DOTNET_PROCESS_MEMORY_WORKING_SET,
+ METRIC_DOTNET_THREAD_POOL_QUEUE_LENGTH: () => METRIC_DOTNET_THREAD_POOL_QUEUE_LENGTH,
+ METRIC_DOTNET_THREAD_POOL_THREAD_COUNT: () => METRIC_DOTNET_THREAD_POOL_THREAD_COUNT,
+ METRIC_DOTNET_THREAD_POOL_WORK_ITEM_COUNT: () => METRIC_DOTNET_THREAD_POOL_WORK_ITEM_COUNT,
+ METRIC_DOTNET_TIMER_COUNT: () => METRIC_DOTNET_TIMER_COUNT,
+ METRIC_HTTP_CLIENT_REQUEST_DURATION: () => METRIC_HTTP_CLIENT_REQUEST_DURATION,
+ METRIC_HTTP_SERVER_REQUEST_DURATION: () => METRIC_HTTP_SERVER_REQUEST_DURATION,
+ METRIC_JVM_CLASS_COUNT: () => METRIC_JVM_CLASS_COUNT,
+ METRIC_JVM_CLASS_LOADED: () => METRIC_JVM_CLASS_LOADED,
+ METRIC_JVM_CLASS_UNLOADED: () => METRIC_JVM_CLASS_UNLOADED,
+ METRIC_JVM_CPU_COUNT: () => METRIC_JVM_CPU_COUNT,
+ METRIC_JVM_CPU_RECENT_UTILIZATION: () => METRIC_JVM_CPU_RECENT_UTILIZATION,
+ METRIC_JVM_CPU_TIME: () => METRIC_JVM_CPU_TIME,
+ METRIC_JVM_GC_DURATION: () => METRIC_JVM_GC_DURATION,
+ METRIC_JVM_MEMORY_COMMITTED: () => METRIC_JVM_MEMORY_COMMITTED,
+ METRIC_JVM_MEMORY_LIMIT: () => METRIC_JVM_MEMORY_LIMIT,
+ METRIC_JVM_MEMORY_USED: () => METRIC_JVM_MEMORY_USED,
+ METRIC_JVM_MEMORY_USED_AFTER_LAST_GC: () => METRIC_JVM_MEMORY_USED_AFTER_LAST_GC,
+ METRIC_JVM_THREAD_COUNT: () => METRIC_JVM_THREAD_COUNT,
+ METRIC_KESTREL_ACTIVE_CONNECTIONS: () => METRIC_KESTREL_ACTIVE_CONNECTIONS,
+ METRIC_KESTREL_ACTIVE_TLS_HANDSHAKES: () => METRIC_KESTREL_ACTIVE_TLS_HANDSHAKES,
+ METRIC_KESTREL_CONNECTION_DURATION: () => METRIC_KESTREL_CONNECTION_DURATION,
+ METRIC_KESTREL_QUEUED_CONNECTIONS: () => METRIC_KESTREL_QUEUED_CONNECTIONS,
+ METRIC_KESTREL_QUEUED_REQUESTS: () => METRIC_KESTREL_QUEUED_REQUESTS,
+ METRIC_KESTREL_REJECTED_CONNECTIONS: () => METRIC_KESTREL_REJECTED_CONNECTIONS,
+ METRIC_KESTREL_TLS_HANDSHAKE_DURATION: () => METRIC_KESTREL_TLS_HANDSHAKE_DURATION,
+ METRIC_KESTREL_UPGRADED_CONNECTIONS: () => METRIC_KESTREL_UPGRADED_CONNECTIONS,
+ METRIC_SIGNALR_SERVER_ACTIVE_CONNECTIONS: () => METRIC_SIGNALR_SERVER_ACTIVE_CONNECTIONS,
+ METRIC_SIGNALR_SERVER_CONNECTION_DURATION: () => METRIC_SIGNALR_SERVER_CONNECTION_DURATION,
+ 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,
+ NETWORK_TRANSPORT_VALUE_PIPE: () => NETWORK_TRANSPORT_VALUE_PIPE,
+ NETWORK_TRANSPORT_VALUE_QUIC: () => NETWORK_TRANSPORT_VALUE_QUIC,
+ NETWORK_TRANSPORT_VALUE_TCP: () => NETWORK_TRANSPORT_VALUE_TCP,
+ NETWORK_TRANSPORT_VALUE_UDP: () => NETWORK_TRANSPORT_VALUE_UDP,
+ NETWORK_TRANSPORT_VALUE_UNIX: () => NETWORK_TRANSPORT_VALUE_UNIX,
+ NETWORK_TYPE_VALUE_IPV4: () => NETWORK_TYPE_VALUE_IPV4,
+ NETWORK_TYPE_VALUE_IPV6: () => NETWORK_TYPE_VALUE_IPV6,
+ 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,
+ OTEL_STATUS_CODE_VALUE_ERROR: () => OTEL_STATUS_CODE_VALUE_ERROR,
+ OTEL_STATUS_CODE_VALUE_OK: () => OTEL_STATUS_CODE_VALUE_OK,
+ 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,
+ SIGNALR_CONNECTION_STATUS_VALUE_APP_SHUTDOWN: () => SIGNALR_CONNECTION_STATUS_VALUE_APP_SHUTDOWN,
+ SIGNALR_CONNECTION_STATUS_VALUE_NORMAL_CLOSURE: () => SIGNALR_CONNECTION_STATUS_VALUE_NORMAL_CLOSURE,
+ SIGNALR_CONNECTION_STATUS_VALUE_TIMEOUT: () => SIGNALR_CONNECTION_STATUS_VALUE_TIMEOUT,
+ SIGNALR_TRANSPORT_VALUE_LONG_POLLING: () => SIGNALR_TRANSPORT_VALUE_LONG_POLLING,
+ SIGNALR_TRANSPORT_VALUE_SERVER_SENT_EVENTS: () => SIGNALR_TRANSPORT_VALUE_SERVER_SENT_EVENTS,
+ SIGNALR_TRANSPORT_VALUE_WEB_SOCKETS: () => SIGNALR_TRANSPORT_VALUE_WEB_SOCKETS,
+ 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,
+ TELEMETRY_SDK_LANGUAGE_VALUE_CPP: () => TELEMETRY_SDK_LANGUAGE_VALUE_CPP,
+ TELEMETRY_SDK_LANGUAGE_VALUE_DOTNET: () => TELEMETRY_SDK_LANGUAGE_VALUE_DOTNET,
+ TELEMETRY_SDK_LANGUAGE_VALUE_ERLANG: () => TELEMETRY_SDK_LANGUAGE_VALUE_ERLANG,
+ TELEMETRY_SDK_LANGUAGE_VALUE_GO: () => TELEMETRY_SDK_LANGUAGE_VALUE_GO,
+ TELEMETRY_SDK_LANGUAGE_VALUE_JAVA: () => TELEMETRY_SDK_LANGUAGE_VALUE_JAVA,
+ TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS: () => TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+ TELEMETRY_SDK_LANGUAGE_VALUE_PHP: () => TELEMETRY_SDK_LANGUAGE_VALUE_PHP,
+ TELEMETRY_SDK_LANGUAGE_VALUE_PYTHON: () => TELEMETRY_SDK_LANGUAGE_VALUE_PYTHON,
+ TELEMETRY_SDK_LANGUAGE_VALUE_RUBY: () => TELEMETRY_SDK_LANGUAGE_VALUE_RUBY,
+ TELEMETRY_SDK_LANGUAGE_VALUE_RUST: () => TELEMETRY_SDK_LANGUAGE_VALUE_RUST,
+ TELEMETRY_SDK_LANGUAGE_VALUE_SWIFT: () => TELEMETRY_SDK_LANGUAGE_VALUE_SWIFT,
+ TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS: () => TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS,
+ TelemetrySdkLanguageValues: () => TelemetrySdkLanguageValues
+});
+var init_esm$1 = __esmMin((() => {
+ init_trace();
+ init_resource();
+ init_stable_attributes();
+ init_stable_metrics();
+ init_stable_events();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/semconv.js
+var require_semconv$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.ATTR_PROCESS_RUNTIME_NAME = void 0;
+ /**
+ * The name of the runtime of this process.
+ *
+ * @example OpenJDK Runtime Environment
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+ exports.ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/platform/node/sdk-info.js
+var require_sdk_info$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.SDK_INFO = void 0;
+ const version_1 = require_version$3();
+ const semantic_conventions_1 = (init_esm$1(), __toCommonJS(esm_exports$1));
+ const semconv_1 = require_semconv$4();
+ /** Constants describing the SDK in use */
+ exports.SDK_INFO = {
+ [semantic_conventions_1.ATTR_TELEMETRY_SDK_NAME]: "opentelemetry",
+ [semconv_1.ATTR_PROCESS_RUNTIME_NAME]: "node",
+ [semantic_conventions_1.ATTR_TELEMETRY_SDK_LANGUAGE]: semantic_conventions_1.TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+ [semantic_conventions_1.ATTR_TELEMETRY_SDK_VERSION]: version_1.VERSION
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/platform/node/timer-util.js
+var require_timer_util$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.unrefTimer = void 0;
+ function unrefTimer(timer) {
+ timer.unref();
+ }
+ exports.unrefTimer = unrefTimer;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/platform/node/index.js
+var require_node$6 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.unrefTimer = exports.SDK_INFO = exports.otperformance = exports._globalThis = exports.getStringListFromEnv = exports.getNumberFromEnv = exports.getBooleanFromEnv = exports.getStringFromEnv = void 0;
+ var environment_1 = require_environment$1();
+ Object.defineProperty(exports, "getStringFromEnv", {
+ enumerable: true,
+ get: function() {
+ return environment_1.getStringFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getBooleanFromEnv", {
+ enumerable: true,
+ get: function() {
+ return environment_1.getBooleanFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getNumberFromEnv", {
+ enumerable: true,
+ get: function() {
+ return environment_1.getNumberFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getStringListFromEnv", {
+ enumerable: true,
+ get: function() {
+ return environment_1.getStringListFromEnv;
+ }
+ });
+ var globalThis_1 = require_globalThis$1();
+ Object.defineProperty(exports, "_globalThis", {
+ enumerable: true,
+ get: function() {
+ return globalThis_1._globalThis;
+ }
+ });
+ var performance_1 = require_performance();
+ Object.defineProperty(exports, "otperformance", {
+ enumerable: true,
+ get: function() {
+ return performance_1.otperformance;
+ }
+ });
+ var sdk_info_1 = require_sdk_info$1();
+ Object.defineProperty(exports, "SDK_INFO", {
+ enumerable: true,
+ get: function() {
+ return sdk_info_1.SDK_INFO;
+ }
+ });
+ var timer_util_1 = require_timer_util$1();
+ Object.defineProperty(exports, "unrefTimer", {
+ enumerable: true,
+ get: function() {
+ return timer_util_1.unrefTimer;
+ }
+ });
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/platform/index.js
+var require_platform$6 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.getStringListFromEnv = exports.getNumberFromEnv = exports.getStringFromEnv = exports.getBooleanFromEnv = exports.unrefTimer = exports.otperformance = exports._globalThis = exports.SDK_INFO = void 0;
+ var node_1 = require_node$6();
+ Object.defineProperty(exports, "SDK_INFO", {
+ enumerable: true,
+ get: function() {
+ return node_1.SDK_INFO;
+ }
+ });
+ Object.defineProperty(exports, "_globalThis", {
+ enumerable: true,
+ get: function() {
+ return node_1._globalThis;
+ }
+ });
+ Object.defineProperty(exports, "otperformance", {
+ enumerable: true,
+ get: function() {
+ return node_1.otperformance;
+ }
+ });
+ Object.defineProperty(exports, "unrefTimer", {
+ enumerable: true,
+ get: function() {
+ return node_1.unrefTimer;
+ }
+ });
+ Object.defineProperty(exports, "getBooleanFromEnv", {
+ enumerable: true,
+ get: function() {
+ return node_1.getBooleanFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getStringFromEnv", {
+ enumerable: true,
+ get: function() {
+ return node_1.getStringFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getNumberFromEnv", {
+ enumerable: true,
+ get: function() {
+ return node_1.getNumberFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getStringListFromEnv", {
+ enumerable: true,
+ get: function() {
+ return node_1.getStringListFromEnv;
+ }
+ });
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/common/time.js
+var require_time$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.addHrTimes = exports.isTimeInput = exports.isTimeInputHrTime = exports.hrTimeToMicroseconds = exports.hrTimeToMilliseconds = exports.hrTimeToNanoseconds = exports.hrTimeToTimeStamp = exports.hrTimeDuration = exports.timeInputToHrTime = exports.hrTime = exports.getTimeOrigin = exports.millisToHrTime = void 0;
+ const platform_1 = require_platform$6();
+ const NANOSECOND_DIGITS = 9;
+ const MILLISECONDS_TO_NANOSECONDS = Math.pow(10, 6);
+ const SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+ /**
+ * Converts a number of milliseconds from epoch to HrTime([seconds, remainder in nanoseconds]).
+ * @param epochMillis
+ */
+ function millisToHrTime(epochMillis) {
+ const epochSeconds = epochMillis / 1e3;
+ return [Math.trunc(epochSeconds), Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS)];
+ }
+ exports.millisToHrTime = millisToHrTime;
+ function getTimeOrigin() {
+ let timeOrigin = platform_1.otperformance.timeOrigin;
+ if (typeof timeOrigin !== "number") {
+ const perf = platform_1.otperformance;
+ timeOrigin = perf.timing && perf.timing.fetchStart;
+ }
+ return timeOrigin;
+ }
+ exports.getTimeOrigin = getTimeOrigin;
+ /**
+ * Returns an hrtime calculated via performance component.
+ * @param performanceNow
+ */
+ function hrTime(performanceNow) {
+ return addHrTimes(millisToHrTime(getTimeOrigin()), millisToHrTime(typeof performanceNow === "number" ? performanceNow : platform_1.otperformance.now()));
+ }
+ exports.hrTime = hrTime;
+ /**
+ *
+ * Converts a TimeInput to an HrTime, defaults to _hrtime().
+ * @param time
+ */
+ function timeInputToHrTime(time) {
+ if (isTimeInputHrTime(time)) return time;
+ else if (typeof time === "number") if (time < getTimeOrigin()) return hrTime(time);
+ else return millisToHrTime(time);
+ else if (time instanceof Date) return millisToHrTime(time.getTime());
+ else throw TypeError("Invalid input type");
+ }
+ exports.timeInputToHrTime = timeInputToHrTime;
+ /**
+ * Returns a duration of two hrTime.
+ * @param startTime
+ * @param endTime
+ */
+ function hrTimeDuration(startTime, endTime) {
+ let seconds = endTime[0] - startTime[0];
+ let nanos = endTime[1] - startTime[1];
+ if (nanos < 0) {
+ seconds -= 1;
+ nanos += SECOND_TO_NANOSECONDS;
+ }
+ return [seconds, nanos];
+ }
+ exports.hrTimeDuration = hrTimeDuration;
+ /**
+ * Convert hrTime to timestamp, for example "2019-05-14T17:00:00.000123456Z"
+ * @param time
+ */
+ function hrTimeToTimeStamp(time) {
+ const precision = NANOSECOND_DIGITS;
+ const tmp = `${"0".repeat(precision)}${time[1]}Z`;
+ const nanoString = tmp.substring(tmp.length - precision - 1);
+ return (/* @__PURE__ */ new Date(time[0] * 1e3)).toISOString().replace("000Z", nanoString);
+ }
+ exports.hrTimeToTimeStamp = hrTimeToTimeStamp;
+ /**
+ * Convert hrTime to nanoseconds.
+ * @param time
+ */
+ function hrTimeToNanoseconds(time) {
+ return time[0] * SECOND_TO_NANOSECONDS + time[1];
+ }
+ exports.hrTimeToNanoseconds = hrTimeToNanoseconds;
+ /**
+ * Convert hrTime to milliseconds.
+ * @param time
+ */
+ function hrTimeToMilliseconds(time) {
+ return time[0] * 1e3 + time[1] / 1e6;
+ }
+ exports.hrTimeToMilliseconds = hrTimeToMilliseconds;
+ /**
+ * Convert hrTime to microseconds.
+ * @param time
+ */
+ function hrTimeToMicroseconds(time) {
+ return time[0] * 1e6 + time[1] / 1e3;
+ }
+ exports.hrTimeToMicroseconds = hrTimeToMicroseconds;
+ /**
+ * check if time is HrTime
+ * @param value
+ */
+ function isTimeInputHrTime(value) {
+ return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+ }
+ exports.isTimeInputHrTime = isTimeInputHrTime;
+ /**
+ * check if input value is a correct types.TimeInput
+ * @param value
+ */
+ function isTimeInput(value) {
+ return isTimeInputHrTime(value) || typeof value === "number" || value instanceof Date;
+ }
+ exports.isTimeInput = isTimeInput;
+ /**
+ * Given 2 HrTime formatted times, return their sum as an HrTime.
+ */
+ function addHrTimes(time1, time2) {
+ const out = [time1[0] + time2[0], time1[1] + time2[1]];
+ if (out[1] >= SECOND_TO_NANOSECONDS) {
+ out[1] -= SECOND_TO_NANOSECONDS;
+ out[0] += 1;
+ }
+ return out;
+ }
+ exports.addHrTimes = addHrTimes;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/ExportResult.js
+var require_ExportResult$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.ExportResultCode = void 0;
+ (function(ExportResultCode$1) {
+ ExportResultCode$1[ExportResultCode$1["SUCCESS"] = 0] = "SUCCESS";
+ ExportResultCode$1[ExportResultCode$1["FAILED"] = 1] = "FAILED";
+ })(exports.ExportResultCode || (exports.ExportResultCode = {}));
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/propagation/composite.js
+var require_composite$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.CompositePropagator = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ /** Combines multiple propagators into a single propagator. */
+ var CompositePropagator = class {
+ _propagators;
+ _fields;
+ /**
+ * Construct a composite propagator from a list of propagators.
+ *
+ * @param [config] Configuration object for composite propagator
+ */
+ constructor(config = {}) {
+ this._propagators = config.propagators ?? [];
+ this._fields = Array.from(new Set(this._propagators.map((p) => typeof p.fields === "function" ? p.fields() : []).reduce((x, y) => x.concat(y), [])));
+ }
+ /**
+ * Run each of the configured propagators with the given context and carrier.
+ * Propagators are run in the order they are configured, so if multiple
+ * propagators write the same carrier key, the propagator later in the list
+ * will "win".
+ *
+ * @param context Context to inject
+ * @param carrier Carrier into which context will be injected
+ */
+ inject(context$1, carrier, setter) {
+ for (const propagator of this._propagators) try {
+ propagator.inject(context$1, carrier, setter);
+ } catch (err) {
+ api_1.diag.warn(`Failed to inject with ${propagator.constructor.name}. Err: ${err.message}`);
+ }
+ }
+ /**
+ * Run each of the configured propagators with the given context and carrier.
+ * Propagators are run in the order they are configured, so if multiple
+ * propagators write the same context key, the propagator later in the list
+ * will "win".
+ *
+ * @param context Context to add values to
+ * @param carrier Carrier from which to extract context
+ */
+ extract(context$1, carrier, getter) {
+ return this._propagators.reduce((ctx, propagator) => {
+ try {
+ return propagator.extract(ctx, carrier, getter);
+ } catch (err) {
+ api_1.diag.warn(`Failed to extract with ${propagator.constructor.name}. Err: ${err.message}`);
+ }
+ return ctx;
+ }, context$1);
+ }
+ fields() {
+ return this._fields.slice();
+ }
+ };
+ exports.CompositePropagator = CompositePropagator;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/internal/validators.js
+var require_validators$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.validateValue = exports.validateKey = void 0;
+ const VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+ const VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+ const VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+ const VALID_KEY_REGEX = /* @__PURE__ */ new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+ const VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+ const INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+ /**
+ * Key is opaque string up to 256 characters printable. It MUST begin with a
+ * lowercase letter, and can only contain lowercase letters a-z, digits 0-9,
+ * underscores _, dashes -, asterisks *, and forward slashes /.
+ * For multi-tenant vendor scenarios, an at sign (@) can be used to prefix the
+ * vendor name. Vendors SHOULD set the tenant ID at the beginning of the key.
+ * see https://www.w3.org/TR/trace-context/#key
+ */
+ function validateKey(key) {
+ return VALID_KEY_REGEX.test(key);
+ }
+ exports.validateKey = validateKey;
+ /**
+ * Value is opaque string up to 256 characters printable ASCII RFC0020
+ * characters (i.e., the range 0x20 to 0x7E) except comma , and =.
+ */
+ function validateValue(value) {
+ return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+ }
+ exports.validateValue = validateValue;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/trace/TraceState.js
+var require_TraceState$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.TraceState = void 0;
+ const validators_1 = require_validators$1();
+ const MAX_TRACE_STATE_ITEMS = 32;
+ const MAX_TRACE_STATE_LEN = 512;
+ const LIST_MEMBERS_SEPARATOR = ",";
+ const LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+ /**
+ * TraceState must be a class and not a simple object type because of the spec
+ * requirement (https://www.w3.org/TR/trace-context/#tracestate-field).
+ *
+ * Here is the list of allowed mutations:
+ * - New key-value pair should be added into the beginning of the list
+ * - The value of any key can be updated. Modified keys MUST be moved to the
+ * beginning of the list.
+ */
+ var TraceState = class TraceState {
+ _internalState = /* @__PURE__ */ new Map();
+ constructor(rawTraceState) {
+ if (rawTraceState) this._parse(rawTraceState);
+ }
+ set(key, value) {
+ const traceState = this._clone();
+ if (traceState._internalState.has(key)) traceState._internalState.delete(key);
+ traceState._internalState.set(key, value);
+ return traceState;
+ }
+ unset(key) {
+ const traceState = this._clone();
+ traceState._internalState.delete(key);
+ return traceState;
+ }
+ get(key) {
+ return this._internalState.get(key);
+ }
+ serialize() {
+ return this._keys().reduce((agg, key) => {
+ agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+ return agg;
+ }, []).join(LIST_MEMBERS_SEPARATOR);
+ }
+ _parse(rawTraceState) {
+ if (rawTraceState.length > MAX_TRACE_STATE_LEN) return;
+ this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
+ const listMember = part.trim();
+ const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+ if (i !== -1) {
+ const key = listMember.slice(0, i);
+ const value = listMember.slice(i + 1, part.length);
+ if ((0, validators_1.validateKey)(key) && (0, validators_1.validateValue)(value)) agg.set(key, value);
+ }
+ 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));
+ }
+ _keys() {
+ return Array.from(this._internalState.keys()).reverse();
+ }
+ _clone() {
+ const traceState = new TraceState();
+ traceState._internalState = new Map(this._internalState);
+ return traceState;
+ }
+ };
+ exports.TraceState = TraceState;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/trace/W3CTraceContextPropagator.js
+var require_W3CTraceContextPropagator$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.W3CTraceContextPropagator = exports.parseTraceParent = exports.TRACE_STATE_HEADER = exports.TRACE_PARENT_HEADER = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ const suppress_tracing_1 = require_suppress_tracing$1();
+ const TraceState_1 = require_TraceState$1();
+ exports.TRACE_PARENT_HEADER = "traceparent";
+ exports.TRACE_STATE_HEADER = "tracestate";
+ const VERSION = "00";
+ const TRACE_PARENT_REGEX = /* @__PURE__ */ new RegExp(`^\\s?((?!ff)[\\da-f]{2})-((?![0]{32})[\\da-f]{32})-((?![0]{16})[\\da-f]{16})-([\\da-f]{2})(-.*)?\\s?$`);
+ /**
+ * Parses information from the [traceparent] span tag and converts it into {@link SpanContext}
+ * @param traceParent - A meta property that comes from server.
+ * It should be dynamically generated server side to have the server's request trace Id,
+ * a parent span Id that was set on the server's request span,
+ * and the trace flags to indicate the server's sampling decision
+ * (01 = sampled, 00 = not sampled).
+ * for example: '{version}-{traceId}-{spanId}-{sampleDecision}'
+ * For more information see {@link https://www.w3.org/TR/trace-context/}
+ */
+ function parseTraceParent(traceParent) {
+ const match = TRACE_PARENT_REGEX.exec(traceParent);
+ if (!match) return null;
+ if (match[1] === "00" && match[5]) return null;
+ return {
+ traceId: match[2],
+ spanId: match[3],
+ traceFlags: parseInt(match[4], 16)
+ };
+ }
+ exports.parseTraceParent = parseTraceParent;
+ /**
+ * Propagates {@link SpanContext} through Trace Context format propagation.
+ *
+ * Based on the Trace Context specification:
+ * https://www.w3.org/TR/trace-context/
+ */
+ var W3CTraceContextPropagator = class {
+ inject(context$1, carrier, setter) {
+ const spanContext = api_1.trace.getSpanContext(context$1);
+ if (!spanContext || (0, suppress_tracing_1.isTracingSuppressed)(context$1) || !(0, api_1.isSpanContextValid)(spanContext)) return;
+ const traceParent = `${VERSION}-${spanContext.traceId}-${spanContext.spanId}-0${Number(spanContext.traceFlags || api_1.TraceFlags.NONE).toString(16)}`;
+ setter.set(carrier, exports.TRACE_PARENT_HEADER, traceParent);
+ if (spanContext.traceState) setter.set(carrier, exports.TRACE_STATE_HEADER, spanContext.traceState.serialize());
+ }
+ extract(context$1, carrier, getter) {
+ const traceParentHeader = getter.get(carrier, exports.TRACE_PARENT_HEADER);
+ if (!traceParentHeader) return context$1;
+ const traceParent = Array.isArray(traceParentHeader) ? traceParentHeader[0] : traceParentHeader;
+ if (typeof traceParent !== "string") return context$1;
+ const spanContext = parseTraceParent(traceParent);
+ if (!spanContext) return context$1;
+ spanContext.isRemote = true;
+ const traceStateHeader = getter.get(carrier, exports.TRACE_STATE_HEADER);
+ if (traceStateHeader) {
+ const state = Array.isArray(traceStateHeader) ? traceStateHeader.join(",") : traceStateHeader;
+ spanContext.traceState = new TraceState_1.TraceState(typeof state === "string" ? state : void 0);
+ }
+ return api_1.trace.setSpanContext(context$1, spanContext);
+ }
+ fields() {
+ return [exports.TRACE_PARENT_HEADER, exports.TRACE_STATE_HEADER];
+ }
+ };
+ exports.W3CTraceContextPropagator = W3CTraceContextPropagator;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/trace/rpc-metadata.js
+var require_rpc_metadata$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.getRPCMetadata = exports.deleteRPCMetadata = exports.setRPCMetadata = exports.RPCType = void 0;
+ const RPC_METADATA_KEY = (0, (init_esm$2(), __toCommonJS(esm_exports$2)).createContextKey)("OpenTelemetry SDK Context Key RPC_METADATA");
+ (function(RPCType) {
+ RPCType["HTTP"] = "http";
+ })(exports.RPCType || (exports.RPCType = {}));
+ function setRPCMetadata(context$1, meta) {
+ return context$1.setValue(RPC_METADATA_KEY, meta);
+ }
+ exports.setRPCMetadata = setRPCMetadata;
+ function deleteRPCMetadata(context$1) {
+ return context$1.deleteValue(RPC_METADATA_KEY);
+ }
+ exports.deleteRPCMetadata = deleteRPCMetadata;
+ function getRPCMetadata(context$1) {
+ return context$1.getValue(RPC_METADATA_KEY);
+ }
+ exports.getRPCMetadata = getRPCMetadata;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/utils/lodash.merge.js
+var require_lodash_merge$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.isPlainObject = void 0;
+ /**
+ * based on lodash in order to support esm builds without esModuleInterop.
+ * lodash is using MIT License.
+ **/
+ const objectTag = "[object Object]";
+ const nullTag = "[object Null]";
+ const undefinedTag = "[object Undefined]";
+ const funcToString = Function.prototype.toString;
+ const objectCtorString = funcToString.call(Object);
+ const getPrototypeOf = Object.getPrototypeOf;
+ const objectProto = Object.prototype;
+ const hasOwnProperty = objectProto.hasOwnProperty;
+ const symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+ const nativeObjectToString = objectProto.toString;
+ /**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+ function isPlainObject(value) {
+ if (!isObjectLike(value) || baseGetTag(value) !== objectTag) return false;
+ const proto = getPrototypeOf(value);
+ if (proto === null) return true;
+ const Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+ return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
+ }
+ exports.isPlainObject = isPlainObject;
+ /**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+ function isObjectLike(value) {
+ return value != null && typeof value == "object";
+ }
+ /**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+ function baseGetTag(value) {
+ if (value == null) return value === void 0 ? undefinedTag : nullTag;
+ return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+ }
+ /**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+ function getRawTag(value) {
+ const isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+ let unmasked = false;
+ try {
+ value[symToStringTag] = void 0;
+ unmasked = true;
+ } catch {}
+ const result = nativeObjectToString.call(value);
+ if (unmasked) if (isOwn) value[symToStringTag] = tag;
+ else delete value[symToStringTag];
+ return result;
+ }
+ /**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+ function objectToString(value) {
+ return nativeObjectToString.call(value);
+ }
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/utils/merge.js
+var require_merge$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.merge = void 0;
+ const lodash_merge_1 = require_lodash_merge$1();
+ const MAX_LEVEL = 20;
+ /**
+ * Merges objects together
+ * @param args - objects / values to be merged
+ */
+ function merge(...args) {
+ let result = args.shift();
+ const objects = /* @__PURE__ */ new WeakMap();
+ while (args.length > 0) result = mergeTwoObjects(result, args.shift(), 0, objects);
+ return result;
+ }
+ exports.merge = merge;
+ function takeValue(value) {
+ if (isArray(value)) return value.slice();
+ return value;
+ }
+ /**
+ * Merges two objects
+ * @param one - first object
+ * @param two - second object
+ * @param level - current deep level
+ * @param objects - objects holder that has been already referenced - to prevent
+ * cyclic dependency
+ */
+ function mergeTwoObjects(one, two, level = 0, objects) {
+ let result;
+ if (level > MAX_LEVEL) return;
+ level++;
+ if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) result = takeValue(two);
+ else if (isArray(one)) {
+ result = one.slice();
+ if (isArray(two)) for (let i = 0, j = two.length; i < j; i++) result.push(takeValue(two[i]));
+ else if (isObject(two)) {
+ const keys = Object.keys(two);
+ for (let i = 0, j = keys.length; i < j; i++) {
+ const key = keys[i];
+ result[key] = takeValue(two[key]);
+ }
+ }
+ } else if (isObject(one)) if (isObject(two)) {
+ if (!shouldMerge(one, two)) return two;
+ result = Object.assign({}, one);
+ const keys = Object.keys(two);
+ for (let i = 0, j = keys.length; i < j; i++) {
+ const key = keys[i];
+ const twoValue = two[key];
+ if (isPrimitive(twoValue)) if (typeof twoValue === "undefined") delete result[key];
+ else result[key] = twoValue;
+ else {
+ const obj1 = result[key];
+ const obj2 = twoValue;
+ if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) delete result[key];
+ else {
+ if (isObject(obj1) && isObject(obj2)) {
+ const arr1 = objects.get(obj1) || [];
+ const arr2 = objects.get(obj2) || [];
+ arr1.push({
+ obj: one,
+ key
+ });
+ arr2.push({
+ obj: two,
+ key
+ });
+ objects.set(obj1, arr1);
+ objects.set(obj2, arr2);
+ }
+ result[key] = mergeTwoObjects(result[key], twoValue, level, objects);
+ }
+ }
+ }
+ } else result = two;
+ return result;
+ }
+ /**
+ * Function to check if object has been already reference
+ * @param obj
+ * @param key
+ * @param objects
+ */
+ function wasObjectReferenced(obj, key, objects) {
+ const arr = objects.get(obj[key]) || [];
+ for (let i = 0, j = arr.length; i < j; i++) {
+ const info = arr[i];
+ if (info.key === key && info.obj === obj) return true;
+ }
+ return false;
+ }
+ function isArray(value) {
+ return Array.isArray(value);
+ }
+ function isFunction(value) {
+ return typeof value === "function";
+ }
+ function isObject(value) {
+ return !isPrimitive(value) && !isArray(value) && !isFunction(value) && typeof value === "object";
+ }
+ function isPrimitive(value) {
+ return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null;
+ }
+ function shouldMerge(one, two) {
+ if (!(0, lodash_merge_1.isPlainObject)(one) || !(0, lodash_merge_1.isPlainObject)(two)) return false;
+ return true;
+ }
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/utils/timeout.js
+var require_timeout$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.callWithTimeout = exports.TimeoutError = void 0;
+ /**
+ * Error that is thrown on timeouts.
+ */
+ var TimeoutError = class TimeoutError extends Error {
+ constructor(message) {
+ super(message);
+ Object.setPrototypeOf(this, TimeoutError.prototype);
+ }
+ };
+ exports.TimeoutError = TimeoutError;
+ /**
+ * Adds a timeout to a promise and rejects if the specified timeout has elapsed. Also rejects if the specified promise
+ * rejects, and resolves if the specified promise resolves.
+ *
+ * NOTE: this operation will continue even after it throws a {@link TimeoutError}.
+ *
+ * @param promise promise to use with timeout.
+ * @param timeout the timeout in milliseconds until the returned promise is rejected.
+ */
+ function callWithTimeout(promise, timeout) {
+ let timeoutHandle;
+ const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) {
+ timeoutHandle = setTimeout(function timeoutHandler() {
+ reject(new TimeoutError("Operation timed out."));
+ }, timeout);
+ });
+ return Promise.race([promise, timeoutPromise]).then((result) => {
+ clearTimeout(timeoutHandle);
+ return result;
+ }, (reason) => {
+ clearTimeout(timeoutHandle);
+ throw reason;
+ });
+ }
+ exports.callWithTimeout = callWithTimeout;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/utils/url.js
+var require_url$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.isUrlIgnored = exports.urlMatches = void 0;
+ function urlMatches(url, urlToMatch) {
+ if (typeof urlToMatch === "string") return url === urlToMatch;
+ else return !!url.match(urlToMatch);
+ }
+ exports.urlMatches = urlMatches;
+ /**
+ * Check if {@param url} should be ignored when comparing against {@param ignoredUrls}
+ * @param url
+ * @param ignoredUrls
+ */
+ function isUrlIgnored(url, ignoredUrls) {
+ if (!ignoredUrls) return false;
+ for (const ignoreUrl of ignoredUrls) if (urlMatches(url, ignoreUrl)) return true;
+ return false;
+ }
+ exports.isUrlIgnored = isUrlIgnored;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/utils/promise.js
+var require_promise$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.Deferred = void 0;
+ var Deferred = class {
+ _promise;
+ _resolve;
+ _reject;
+ constructor() {
+ this._promise = new Promise((resolve, reject) => {
+ this._resolve = resolve;
+ this._reject = reject;
+ });
+ }
+ get promise() {
+ return this._promise;
+ }
+ resolve(val) {
+ this._resolve(val);
+ }
+ reject(err) {
+ this._reject(err);
+ }
+ };
+ exports.Deferred = Deferred;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/utils/callback.js
+var require_callback$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.BindOnceFuture = void 0;
+ const promise_1 = require_promise$1();
+ /**
+ * Bind the callback and only invoke the callback once regardless how many times `BindOnceFuture.call` is invoked.
+ */
+ var BindOnceFuture = class {
+ _callback;
+ _that;
+ _isCalled = false;
+ _deferred = new promise_1.Deferred();
+ constructor(_callback, _that) {
+ this._callback = _callback;
+ this._that = _that;
+ }
+ get isCalled() {
+ return this._isCalled;
+ }
+ get promise() {
+ return this._deferred.promise;
+ }
+ call(...args) {
+ if (!this._isCalled) {
+ this._isCalled = true;
+ try {
+ Promise.resolve(this._callback.call(this._that, ...args)).then((val) => this._deferred.resolve(val), (err) => this._deferred.reject(err));
+ } catch (err) {
+ this._deferred.reject(err);
+ }
+ }
+ return this._deferred.promise;
+ }
+ };
+ exports.BindOnceFuture = BindOnceFuture;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/utils/configuration.js
+var require_configuration$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.diagLogLevelFromString = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ const logLevelMap = {
+ ALL: api_1.DiagLogLevel.ALL,
+ VERBOSE: api_1.DiagLogLevel.VERBOSE,
+ DEBUG: api_1.DiagLogLevel.DEBUG,
+ INFO: api_1.DiagLogLevel.INFO,
+ WARN: api_1.DiagLogLevel.WARN,
+ ERROR: api_1.DiagLogLevel.ERROR,
+ NONE: api_1.DiagLogLevel.NONE
+ };
+ /**
+ * Convert a string to a {@link DiagLogLevel}, defaults to {@link DiagLogLevel} if the log level does not exist or undefined if the input is undefined.
+ * @param value
+ */
+ function diagLogLevelFromString(value) {
+ if (value == null) return;
+ const resolvedLogLevel = logLevelMap[value.toUpperCase()];
+ if (resolvedLogLevel == null) {
+ api_1.diag.warn(`Unknown log level "${value}", expected one of ${Object.keys(logLevelMap)}, using default`);
+ return api_1.DiagLogLevel.INFO;
+ }
+ return resolvedLogLevel;
+ }
+ exports.diagLogLevelFromString = diagLogLevelFromString;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/internal/exporter.js
+var require_exporter$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports._export = void 0;
+ const api_1 = (init_esm$2(), __toCommonJS(esm_exports$2));
+ const suppress_tracing_1 = require_suppress_tracing$1();
+ /**
+ * @internal
+ * Shared functionality used by Exporters while exporting data, including suppression of Traces.
+ */
+ function _export(exporter, arg) {
+ return new Promise((resolve) => {
+ api_1.context.with((0, suppress_tracing_1.suppressTracing)(api_1.context.active()), () => {
+ exporter.export(arg, (result) => {
+ resolve(result);
+ });
+ });
+ });
+ }
+ exports._export = _export;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.1.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/src/index.js
+var require_src$9 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.internal = exports.diagLogLevelFromString = exports.BindOnceFuture = exports.urlMatches = exports.isUrlIgnored = exports.callWithTimeout = exports.TimeoutError = exports.merge = exports.TraceState = exports.unsuppressTracing = exports.suppressTracing = exports.isTracingSuppressed = exports.setRPCMetadata = exports.getRPCMetadata = exports.deleteRPCMetadata = exports.RPCType = exports.parseTraceParent = exports.W3CTraceContextPropagator = exports.TRACE_STATE_HEADER = exports.TRACE_PARENT_HEADER = exports.CompositePropagator = exports.unrefTimer = exports.otperformance = exports.getStringListFromEnv = exports.getNumberFromEnv = exports.getBooleanFromEnv = exports.getStringFromEnv = exports._globalThis = exports.SDK_INFO = exports.parseKeyPairsIntoRecord = exports.ExportResultCode = exports.timeInputToHrTime = exports.millisToHrTime = exports.isTimeInputHrTime = exports.isTimeInput = exports.hrTimeToTimeStamp = exports.hrTimeToNanoseconds = exports.hrTimeToMilliseconds = exports.hrTimeToMicroseconds = exports.hrTimeDuration = exports.hrTime = exports.getTimeOrigin = exports.addHrTimes = exports.loggingErrorHandler = exports.setGlobalErrorHandler = exports.globalErrorHandler = exports.sanitizeAttributes = exports.isAttributeValue = exports.AnchoredClock = exports.W3CBaggagePropagator = void 0;
+ var W3CBaggagePropagator_1 = require_W3CBaggagePropagator$1();
+ Object.defineProperty(exports, "W3CBaggagePropagator", {
+ enumerable: true,
+ get: function() {
+ return W3CBaggagePropagator_1.W3CBaggagePropagator;
+ }
+ });
+ var anchored_clock_1 = require_anchored_clock$1();
+ Object.defineProperty(exports, "AnchoredClock", {
+ enumerable: true,
+ get: function() {
+ return anchored_clock_1.AnchoredClock;
+ }
+ });
+ var attributes_1 = require_attributes$1();
+ Object.defineProperty(exports, "isAttributeValue", {
+ enumerable: true,
+ get: function() {
+ return attributes_1.isAttributeValue;
+ }
+ });
+ Object.defineProperty(exports, "sanitizeAttributes", {
+ enumerable: true,
+ get: function() {
+ return attributes_1.sanitizeAttributes;
+ }
+ });
+ var global_error_handler_1 = require_global_error_handler$1();
+ Object.defineProperty(exports, "globalErrorHandler", {
+ enumerable: true,
+ get: function() {
+ return global_error_handler_1.globalErrorHandler;
+ }
+ });
+ Object.defineProperty(exports, "setGlobalErrorHandler", {
+ enumerable: true,
+ get: function() {
+ return global_error_handler_1.setGlobalErrorHandler;
+ }
+ });
+ var logging_error_handler_1 = require_logging_error_handler$1();
+ Object.defineProperty(exports, "loggingErrorHandler", {
+ enumerable: true,
+ get: function() {
+ return logging_error_handler_1.loggingErrorHandler;
+ }
+ });
+ var time_1 = require_time$1();
+ Object.defineProperty(exports, "addHrTimes", {
+ enumerable: true,
+ get: function() {
+ return time_1.addHrTimes;
+ }
+ });
+ Object.defineProperty(exports, "getTimeOrigin", {
+ enumerable: true,
+ get: function() {
+ return time_1.getTimeOrigin;
+ }
+ });
+ Object.defineProperty(exports, "hrTime", {
+ enumerable: true,
+ get: function() {
+ return time_1.hrTime;
+ }
+ });
+ Object.defineProperty(exports, "hrTimeDuration", {
+ enumerable: true,
+ get: function() {
+ return time_1.hrTimeDuration;
+ }
+ });
+ Object.defineProperty(exports, "hrTimeToMicroseconds", {
+ enumerable: true,
+ get: function() {
+ return time_1.hrTimeToMicroseconds;
+ }
+ });
+ Object.defineProperty(exports, "hrTimeToMilliseconds", {
+ enumerable: true,
+ get: function() {
+ return time_1.hrTimeToMilliseconds;
+ }
+ });
+ Object.defineProperty(exports, "hrTimeToNanoseconds", {
+ enumerable: true,
+ get: function() {
+ return time_1.hrTimeToNanoseconds;
+ }
+ });
+ Object.defineProperty(exports, "hrTimeToTimeStamp", {
+ enumerable: true,
+ get: function() {
+ return time_1.hrTimeToTimeStamp;
+ }
+ });
+ Object.defineProperty(exports, "isTimeInput", {
+ enumerable: true,
+ get: function() {
+ return time_1.isTimeInput;
+ }
+ });
+ Object.defineProperty(exports, "isTimeInputHrTime", {
+ enumerable: true,
+ get: function() {
+ return time_1.isTimeInputHrTime;
+ }
+ });
+ Object.defineProperty(exports, "millisToHrTime", {
+ enumerable: true,
+ get: function() {
+ return time_1.millisToHrTime;
+ }
+ });
+ Object.defineProperty(exports, "timeInputToHrTime", {
+ enumerable: true,
+ get: function() {
+ return time_1.timeInputToHrTime;
+ }
+ });
+ var ExportResult_1 = require_ExportResult$1();
+ Object.defineProperty(exports, "ExportResultCode", {
+ enumerable: true,
+ get: function() {
+ return ExportResult_1.ExportResultCode;
+ }
+ });
+ var utils_1 = require_utils$7();
+ Object.defineProperty(exports, "parseKeyPairsIntoRecord", {
+ enumerable: true,
+ get: function() {
+ return utils_1.parseKeyPairsIntoRecord;
+ }
+ });
+ var platform_1 = require_platform$6();
+ Object.defineProperty(exports, "SDK_INFO", {
+ enumerable: true,
+ get: function() {
+ return platform_1.SDK_INFO;
+ }
+ });
+ Object.defineProperty(exports, "_globalThis", {
+ enumerable: true,
+ get: function() {
+ return platform_1._globalThis;
+ }
+ });
+ Object.defineProperty(exports, "getStringFromEnv", {
+ enumerable: true,
+ get: function() {
+ return platform_1.getStringFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getBooleanFromEnv", {
+ enumerable: true,
+ get: function() {
+ return platform_1.getBooleanFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getNumberFromEnv", {
+ enumerable: true,
+ get: function() {
+ return platform_1.getNumberFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "getStringListFromEnv", {
+ enumerable: true,
+ get: function() {
+ return platform_1.getStringListFromEnv;
+ }
+ });
+ Object.defineProperty(exports, "otperformance", {
+ enumerable: true,
+ get: function() {
+ return platform_1.otperformance;
+ }
+ });
+ Object.defineProperty(exports, "unrefTimer", {
+ enumerable: true,
+ get: function() {
+ return platform_1.unrefTimer;
+ }
+ });
+ var composite_1 = require_composite$1();
+ Object.defineProperty(exports, "CompositePropagator", {
+ enumerable: true,
+ get: function() {
+ return composite_1.CompositePropagator;
+ }
+ });
+ var W3CTraceContextPropagator_1 = require_W3CTraceContextPropagator$1();
+ Object.defineProperty(exports, "TRACE_PARENT_HEADER", {
+ enumerable: true,
+ get: function() {
+ return W3CTraceContextPropagator_1.TRACE_PARENT_HEADER;
+ }
+ });
+ Object.defineProperty(exports, "TRACE_STATE_HEADER", {
+ enumerable: true,
+ get: function() {
+ return W3CTraceContextPropagator_1.TRACE_STATE_HEADER;
+ }
+ });
+ Object.defineProperty(exports, "W3CTraceContextPropagator", {
+ enumerable: true,
+ get: function() {
+ return W3CTraceContextPropagator_1.W3CTraceContextPropagator;
+ }
+ });
+ Object.defineProperty(exports, "parseTraceParent", {
+ enumerable: true,
+ get: function() {
+ return W3CTraceContextPropagator_1.parseTraceParent;
+ }
+ });
+ var rpc_metadata_1 = require_rpc_metadata$1();
+ Object.defineProperty(exports, "RPCType", {
+ enumerable: true,
+ get: function() {
+ return rpc_metadata_1.RPCType;
+ }
+ });
+ Object.defineProperty(exports, "deleteRPCMetadata", {
+ enumerable: true,
+ get: function() {
+ return rpc_metadata_1.deleteRPCMetadata;
+ }
+ });
+ Object.defineProperty(exports, "getRPCMetadata", {
+ enumerable: true,
+ get: function() {
+ return rpc_metadata_1.getRPCMetadata;
+ }
+ });
+ Object.defineProperty(exports, "setRPCMetadata", {
+ enumerable: true,
+ get: function() {
+ return rpc_metadata_1.setRPCMetadata;
+ }
+ });
+ var suppress_tracing_1 = require_suppress_tracing$1();
+ Object.defineProperty(exports, "isTracingSuppressed", {
+ enumerable: true,
+ get: function() {
+ return suppress_tracing_1.isTracingSuppressed;
+ }
+ });
+ Object.defineProperty(exports, "suppressTracing", {
+ enumerable: true,
+ get: function() {
+ return suppress_tracing_1.suppressTracing;
+ }
+ });
+ Object.defineProperty(exports, "unsuppressTracing", {
+ enumerable: true,
+ get: function() {
+ return suppress_tracing_1.unsuppressTracing;
+ }
+ });
+ var TraceState_1 = require_TraceState$1();
+ Object.defineProperty(exports, "TraceState", {
+ enumerable: true,
+ get: function() {
+ return TraceState_1.TraceState;
+ }
+ });
+ var merge_1 = require_merge$1();
+ Object.defineProperty(exports, "merge", {
+ enumerable: true,
+ get: function() {
+ return merge_1.merge;
+ }
+ });
+ var timeout_1 = require_timeout$1();
+ Object.defineProperty(exports, "TimeoutError", {
+ enumerable: true,
+ get: function() {
+ return timeout_1.TimeoutError;
+ }
+ });
+ Object.defineProperty(exports, "callWithTimeout", {
+ enumerable: true,
+ get: function() {
+ return timeout_1.callWithTimeout;
+ }
+ });
+ var url_1 = require_url$1();
+ Object.defineProperty(exports, "isUrlIgnored", {
+ enumerable: true,
+ get: function() {
+ return url_1.isUrlIgnored;
+ }
+ });
+ Object.defineProperty(exports, "urlMatches", {
+ enumerable: true,
+ get: function() {
+ return url_1.urlMatches;
+ }
+ });
+ var callback_1 = require_callback$1();
+ Object.defineProperty(exports, "BindOnceFuture", {
+ enumerable: true,
+ get: function() {
+ return callback_1.BindOnceFuture;
+ }
+ });
+ var configuration_1 = require_configuration$1();
+ Object.defineProperty(exports, "diagLogLevelFromString", {
+ enumerable: true,
+ get: function() {
+ return configuration_1.diagLogLevelFromString;
+ }
+ });
+ const exporter_1 = require_exporter$1();
+ exports.internal = { _export: exporter_1._export };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.205.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js
+function isPartialSuccessResponse(response) {
+ return Object.prototype.hasOwnProperty.call(response, "partialSuccess");
+}
+/**
+* Default response handler that logs a partial success to the console.
+*/
+function createLoggingPartialSuccessResponseHandler() {
+ return { handleResponse(response) {
+ if (response == null || !isPartialSuccessResponse(response) || response.partialSuccess == null || Object.keys(response.partialSuccess).length === 0) return;
+ diag.warn("Received Partial Success response:", JSON.stringify(response.partialSuccess));
+ } };
+}
+var init_logging_response_handler = __esmMin((() => {
+ init_esm$2();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.205.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js
+/**
+* Creates a generic delegate for OTLP exports which only contains parts of the OTLP export that are shared across all
+* signals.
+*/
+function createOtlpExportDelegate(components, settings) {
+ return new OTLPExportDelegate(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler(), components.promiseHandler, settings.timeout);
+}
+var import_src$4, OTLPExportDelegate;
+var init_otlp_export_delegate = __esmMin((() => {
+ import_src$4 = require_src$9();
+ init_types$1();
+ init_logging_response_handler();
+ init_esm$2();
+ OTLPExportDelegate = class {
+ _transport;
+ _serializer;
+ _responseHandler;
+ _promiseQueue;
+ _timeout;
+ _diagLogger;
+ constructor(_transport, _serializer, _responseHandler, _promiseQueue, _timeout) {
+ this._transport = _transport;
+ this._serializer = _serializer;
+ this._responseHandler = _responseHandler;
+ this._promiseQueue = _promiseQueue;
+ this._timeout = _timeout;
+ this._diagLogger = diag.createComponentLogger({ namespace: "OTLPExportDelegate" });
+ }
+ export(internalRepresentation, resultCallback) {
+ this._diagLogger.debug("items to be sent", internalRepresentation);
+ if (this._promiseQueue.hasReachedLimit()) {
+ resultCallback({
+ code: import_src$4.ExportResultCode.FAILED,
+ error: /* @__PURE__ */ new Error("Concurrent export limit reached")
+ });
+ return;
+ }
+ const serializedRequest = this._serializer.serializeRequest(internalRepresentation);
+ if (serializedRequest == null) {
+ resultCallback({
+ code: import_src$4.ExportResultCode.FAILED,
+ error: /* @__PURE__ */ new Error("Nothing to send")
+ });
+ return;
+ }
+ this._promiseQueue.pushPromise(this._transport.send(serializedRequest, this._timeout).then((response) => {
+ if (response.status === "success") {
+ if (response.data != null) try {
+ this._responseHandler.handleResponse(this._serializer.deserializeResponse(response.data));
+ } catch (e) {
+ this._diagLogger.warn("Export succeeded but could not deserialize response - is the response specification compliant?", e, response.data);
+ }
+ resultCallback({ code: import_src$4.ExportResultCode.SUCCESS });
+ return;
+ } else if (response.status === "failure" && response.error) {
+ resultCallback({
+ code: import_src$4.ExportResultCode.FAILED,
+ error: response.error
+ });
+ return;
+ } else if (response.status === "retryable") resultCallback({
+ code: import_src$4.ExportResultCode.FAILED,
+ error: new OTLPExporterError("Export failed with retryable status")
+ });
+ else resultCallback({
+ code: import_src$4.ExportResultCode.FAILED,
+ error: new OTLPExporterError("Export failed with unknown error")
+ });
+ }, (reason) => resultCallback({
+ code: import_src$4.ExportResultCode.FAILED,
+ error: reason
+ })));
+ }
+ forceFlush() {
+ return this._promiseQueue.awaitAll();
+ }
+ async shutdown() {
+ this._diagLogger.debug("shutdown started");
+ await this.forceFlush();
+ this._transport.shutdown();
+ }
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.205.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-network-export-delegate.js
+function createOtlpNetworkExportDelegate(options, serializer, transport) {
+ return createOtlpExportDelegate({
+ transport,
+ serializer,
+ promiseHandler: createBoundedQueueExportPromiseHandler(options)
+ }, { timeout: options.timeoutMillis });
+}
+var init_otlp_network_export_delegate = __esmMin((() => {
+ init_bounded_queue_export_promise_handler();
+ init_otlp_export_delegate();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.205.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/index.js
+var esm_exports = /* @__PURE__ */ __exportAll({
+ CompressionAlgorithm: () => CompressionAlgorithm,
+ OTLPExporterBase: () => OTLPExporterBase,
+ OTLPExporterError: () => OTLPExporterError,
+ createOtlpNetworkExportDelegate: () => createOtlpNetworkExportDelegate,
+ getSharedConfigurationDefaults: () => getSharedConfigurationDefaults,
+ mergeOtlpSharedConfigurationWithDefaults: () => mergeOtlpSharedConfigurationWithDefaults
+});
+var init_esm = __esmMin((() => {
+ init_OTLPExporterBase();
+ init_types$1();
+ init_shared_configuration();
+ init_legacy_node_configuration();
+ init_otlp_network_export_delegate();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@protobufjs+aspromise@1.1.2/node_modules/@protobufjs/aspromise/index.js
+var require_aspromise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = asPromise;
+ /**
+ * Callback as used by {@link util.asPromise}.
+ * @typedef asPromiseCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {...*} params Additional arguments
+ * @returns {undefined}
+ */
+ /**
+ * Returns a promise from a node-style callback function.
+ * @memberof util
+ * @param {asPromiseCallback} fn Function to call
+ * @param {*} ctx Function context
+ * @param {...*} params Function arguments
+ * @returns {Promise<*>} Promisified function
+ */
+ function asPromise(fn, ctx) {
+ var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
+ while (index < arguments.length) params[offset++] = arguments[index++];
+ return new Promise(function executor(resolve, reject) {
+ params[offset] = function callback(err) {
+ if (pending) {
+ pending = false;
+ if (err) reject(err);
+ else {
+ var params$1 = new Array(arguments.length - 1), offset$1 = 0;
+ while (offset$1 < params$1.length) params$1[offset$1++] = arguments[offset$1];
+ resolve.apply(null, params$1);
+ }
+ }
+ };
+ try {
+ fn.apply(ctx || null, params);
+ } catch (err) {
+ if (pending) {
+ pending = false;
+ reject(err);
+ }
+ }
+ });
+ }
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@protobufjs+base64@1.1.2/node_modules/@protobufjs/base64/index.js
+var require_base64 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ /**
+ * A minimal base64 implementation for number arrays.
+ * @memberof util
+ * @namespace
+ */
+ var base64 = exports;
+ /**
+ * Calculates the byte length of a base64 encoded string.
+ * @param {string} string Base64 encoded string
+ * @returns {number} Byte length
+ */
+ base64.length = function length(string) {
+ var p = string.length;
+ if (!p) return 0;
+ var n = 0;
+ while (--p % 4 > 1 && string.charAt(p) === "=") ++n;
+ return Math.ceil(string.length * 3) / 4 - n;
+ };
+ var b64 = new Array(64);
+ var s64 = new Array(123);
+ for (var i = 0; i < 64;) s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+ /**
+ * Encodes a buffer to a base64 encoded string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} Base64 encoded string
+ */
+ base64.encode = function encode(buffer, start, end) {
+ var parts = null, chunk = [];
+ var i = 0, j = 0, t;
+ while (start < end) {
+ var b = buffer[start++];
+ switch (j) {
+ case 0:
+ chunk[i++] = b64[b >> 2];
+ t = (b & 3) << 4;
+ j = 1;
+ break;
+ case 1:
+ chunk[i++] = b64[t | b >> 4];
+ t = (b & 15) << 2;
+ j = 2;
+ break;
+ case 2:
+ chunk[i++] = b64[t | b >> 6];
+ chunk[i++] = b64[b & 63];
+ j = 0;
+ break;
+ }
+ if (i > 8191) {
+ (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+ i = 0;
+ }
+ }
+ if (j) {
+ chunk[i++] = b64[t];
+ chunk[i++] = 61;
+ if (j === 1) chunk[i++] = 61;
+ }
+ if (parts) {
+ if (i) parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+ return parts.join("");
+ }
+ return String.fromCharCode.apply(String, chunk.slice(0, i));
+ };
+ var invalidEncoding = "invalid encoding";
+ /**
+ * Decodes a base64 encoded string to a buffer.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Number of bytes written
+ * @throws {Error} If encoding is invalid
+ */
+ base64.decode = function decode(string, buffer, offset) {
+ var start = offset;
+ var j = 0, t;
+ for (var i = 0; i < string.length;) {
+ var c = string.charCodeAt(i++);
+ if (c === 61 && j > 1) break;
+ if ((c = s64[c]) === void 0) throw Error(invalidEncoding);
+ switch (j) {
+ case 0:
+ t = c;
+ j = 1;
+ break;
+ case 1:
+ buffer[offset++] = t << 2 | (c & 48) >> 4;
+ t = c;
+ j = 2;
+ break;
+ case 2:
+ buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+ t = c;
+ j = 3;
+ break;
+ case 3:
+ buffer[offset++] = (t & 3) << 6 | c;
+ j = 0;
+ break;
+ }
+ }
+ if (j === 1) throw Error(invalidEncoding);
+ return offset - start;
+ };
+ /**
+ * Tests if the specified string appears to be base64 encoded.
+ * @param {string} string String to test
+ * @returns {boolean} `true` if probably base64 encoded, otherwise false
+ */
+ base64.test = function test(string) {
+ return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@protobufjs+eventemitter@1.1.1/node_modules/@protobufjs/eventemitter/index.js
+var require_eventemitter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = EventEmitter;
+ /**
+ * Constructs a new event emitter instance.
+ * @classdesc A minimal event emitter.
+ * @memberof util
+ * @constructor
+ */
+ function EventEmitter() {
+ /**
+ * Registered listeners.
+ * @type {Object.}
+ * @private
+ */
+ this._listeners = Object.create(null);
+ }
+ /**
+ * Event listener as used by {@link util.EventEmitter}.
+ * @typedef EventEmitterListener
+ * @type {function}
+ * @param {...*} args Arguments
+ * @returns {undefined}
+ */
+ /**
+ * Registers an event listener.
+ * @param {string} evt Event name
+ * @param {EventEmitterListener} fn Listener
+ * @param {*} [ctx] Listener context
+ * @returns {this} `this`
+ */
+ EventEmitter.prototype.on = function on(evt, fn, ctx) {
+ (this._listeners[evt] || (this._listeners[evt] = [])).push({
+ fn,
+ ctx: ctx || this
+ });
+ return this;
+ };
+ /**
+ * Removes an event listener or any matching listeners if arguments are omitted.
+ * @param {string} [evt] Event name. Removes all listeners if omitted.
+ * @param {EventEmitterListener} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+ * @returns {this} `this`
+ */
+ EventEmitter.prototype.off = function off(evt, fn) {
+ if (evt === void 0) this._listeners = Object.create(null);
+ else if (fn === void 0) this._listeners[evt] = [];
+ else {
+ var listeners = this._listeners[evt];
+ if (!listeners) return this;
+ for (var i = 0; i < listeners.length;) if (listeners[i].fn === fn) listeners.splice(i, 1);
+ else ++i;
+ }
+ return this;
+ };
+ /**
+ * Emits an event by calling its listeners with the specified arguments.
+ * @param {string} evt Event name
+ * @param {...*} args Arguments
+ * @returns {this} `this`
+ */
+ EventEmitter.prototype.emit = function emit(evt) {
+ var listeners = this._listeners[evt];
+ if (listeners) {
+ var args = [], i = 1;
+ for (; i < arguments.length;) args.push(arguments[i++]);
+ for (i = 0; i < listeners.length;) listeners[i].fn.apply(listeners[i++].ctx, args);
+ }
+ return this;
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@protobufjs+float@1.0.2/node_modules/@protobufjs/float/index.js
+var require_float = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = factory(factory);
+ /**
+ * Reads / writes floats / doubles from / to buffers.
+ * @name util.float
+ * @namespace
+ */
+ /**
+ * Writes a 32 bit float to a buffer using little endian byte order.
+ * @name util.float.writeFloatLE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+ /**
+ * Writes a 32 bit float to a buffer using big endian byte order.
+ * @name util.float.writeFloatBE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+ /**
+ * Reads a 32 bit float from a buffer using little endian byte order.
+ * @name util.float.readFloatLE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+ /**
+ * Reads a 32 bit float from a buffer using big endian byte order.
+ * @name util.float.readFloatBE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+ /**
+ * Writes a 64 bit double to a buffer using little endian byte order.
+ * @name util.float.writeDoubleLE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+ /**
+ * Writes a 64 bit double to a buffer using big endian byte order.
+ * @name util.float.writeDoubleBE
+ * @function
+ * @param {number} val Value to write
+ * @param {Uint8Array} buf Target buffer
+ * @param {number} pos Target buffer offset
+ * @returns {undefined}
+ */
+ /**
+ * Reads a 64 bit double from a buffer using little endian byte order.
+ * @name util.float.readDoubleLE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+ /**
+ * Reads a 64 bit double from a buffer using big endian byte order.
+ * @name util.float.readDoubleBE
+ * @function
+ * @param {Uint8Array} buf Source buffer
+ * @param {number} pos Source buffer offset
+ * @returns {number} Value read
+ */
+ function factory(exports$1) {
+ if (typeof Float32Array !== "undefined") (function() {
+ var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128;
+ function writeFloat_f32_cpy(val, buf, pos) {
+ f32[0] = val;
+ buf[pos] = f8b[0];
+ buf[pos + 1] = f8b[1];
+ buf[pos + 2] = f8b[2];
+ buf[pos + 3] = f8b[3];
+ }
+ function writeFloat_f32_rev(val, buf, pos) {
+ f32[0] = val;
+ buf[pos] = f8b[3];
+ buf[pos + 1] = f8b[2];
+ buf[pos + 2] = f8b[1];
+ buf[pos + 3] = f8b[0];
+ }
+ /* istanbul ignore next */
+ exports$1.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+ /* istanbul ignore next */
+ exports$1.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+ function readFloat_f32_cpy(buf, pos) {
+ f8b[0] = buf[pos];
+ f8b[1] = buf[pos + 1];
+ f8b[2] = buf[pos + 2];
+ f8b[3] = buf[pos + 3];
+ return f32[0];
+ }
+ function readFloat_f32_rev(buf, pos) {
+ f8b[3] = buf[pos];
+ f8b[2] = buf[pos + 1];
+ f8b[1] = buf[pos + 2];
+ f8b[0] = buf[pos + 3];
+ return f32[0];
+ }
+ /* istanbul ignore next */
+ exports$1.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+ /* istanbul ignore next */
+ exports$1.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+ })();
+ else (function() {
+ function writeFloat_ieee754(writeUint, val, buf, pos) {
+ var sign = val < 0 ? 1 : 0;
+ if (sign) val = -val;
+ if (val === 0) writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos);
+ else if (isNaN(val)) writeUint(2143289344, buf, pos);
+ else if (val > 34028234663852886e22) writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
+ else if (val < 11754943508222875e-54) writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos);
+ else {
+ var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+ writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+ }
+ }
+ exports$1.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+ exports$1.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+ function readFloat_ieee754(readUint, buf, pos) {
+ var uint = readUint(buf, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
+ return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+ }
+ exports$1.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+ exports$1.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+ })();
+ if (typeof Float64Array !== "undefined") (function() {
+ var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128;
+ function writeDouble_f64_cpy(val, buf, pos) {
+ f64[0] = val;
+ buf[pos] = f8b[0];
+ buf[pos + 1] = f8b[1];
+ buf[pos + 2] = f8b[2];
+ buf[pos + 3] = f8b[3];
+ buf[pos + 4] = f8b[4];
+ buf[pos + 5] = f8b[5];
+ buf[pos + 6] = f8b[6];
+ buf[pos + 7] = f8b[7];
+ }
+ function writeDouble_f64_rev(val, buf, pos) {
+ f64[0] = val;
+ buf[pos] = f8b[7];
+ buf[pos + 1] = f8b[6];
+ buf[pos + 2] = f8b[5];
+ buf[pos + 3] = f8b[4];
+ buf[pos + 4] = f8b[3];
+ buf[pos + 5] = f8b[2];
+ buf[pos + 6] = f8b[1];
+ buf[pos + 7] = f8b[0];
+ }
+ /* istanbul ignore next */
+ exports$1.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+ /* istanbul ignore next */
+ exports$1.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+ function readDouble_f64_cpy(buf, pos) {
+ f8b[0] = buf[pos];
+ f8b[1] = buf[pos + 1];
+ f8b[2] = buf[pos + 2];
+ f8b[3] = buf[pos + 3];
+ f8b[4] = buf[pos + 4];
+ f8b[5] = buf[pos + 5];
+ f8b[6] = buf[pos + 6];
+ f8b[7] = buf[pos + 7];
+ return f64[0];
+ }
+ function readDouble_f64_rev(buf, pos) {
+ f8b[7] = buf[pos];
+ f8b[6] = buf[pos + 1];
+ f8b[5] = buf[pos + 2];
+ f8b[4] = buf[pos + 3];
+ f8b[3] = buf[pos + 4];
+ f8b[2] = buf[pos + 5];
+ f8b[1] = buf[pos + 6];
+ f8b[0] = buf[pos + 7];
+ return f64[0];
+ }
+ /* istanbul ignore next */
+ exports$1.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+ /* istanbul ignore next */
+ exports$1.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+ })();
+ else (function() {
+ function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+ var sign = val < 0 ? 1 : 0;
+ if (sign) val = -val;
+ if (val === 0) {
+ writeUint(0, buf, pos + off0);
+ writeUint(1 / val > 0 ? 0 : 2147483648, buf, pos + off1);
+ } else if (isNaN(val)) {
+ writeUint(0, buf, pos + off0);
+ writeUint(2146959360, buf, pos + off1);
+ } else if (val > 17976931348623157e292) {
+ writeUint(0, buf, pos + off0);
+ writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+ } else {
+ var mantissa;
+ if (val < 22250738585072014e-324) {
+ mantissa = val / 5e-324;
+ writeUint(mantissa >>> 0, buf, pos + off0);
+ writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+ } else {
+ var exponent = Math.floor(Math.log(val) / Math.LN2);
+ if (exponent === 1024) exponent = 1023;
+ mantissa = val * Math.pow(2, -exponent);
+ writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+ writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+ }
+ }
+ }
+ exports$1.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+ exports$1.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+ function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+ var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1);
+ var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo;
+ return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+ }
+ exports$1.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+ exports$1.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+ })();
+ return exports$1;
+ }
+ function writeUintLE(val, buf, pos) {
+ buf[pos] = val & 255;
+ buf[pos + 1] = val >>> 8 & 255;
+ buf[pos + 2] = val >>> 16 & 255;
+ buf[pos + 3] = val >>> 24;
+ }
+ function writeUintBE(val, buf, pos) {
+ buf[pos] = val >>> 24;
+ buf[pos + 1] = val >>> 16 & 255;
+ buf[pos + 2] = val >>> 8 & 255;
+ buf[pos + 3] = val & 255;
+ }
+ function readUintLE(buf, pos) {
+ return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0;
+ }
+ function readUintBE(buf, pos) {
+ return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0;
+ }
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@protobufjs+utf8@1.1.1/node_modules/@protobufjs/utf8/index.js
+var require_utf8 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ /**
+ * A minimal UTF8 implementation for number arrays.
+ * @memberof util
+ * @namespace
+ */
+ var utf8 = exports, replacementChar = "�";
+ /**
+ * Calculates the UTF8 byte length of a string.
+ * @param {string} string String
+ * @returns {number} Byte length
+ */
+ utf8.length = function utf8_length(string) {
+ var len = 0, c = 0;
+ for (var i = 0; i < string.length; ++i) {
+ c = string.charCodeAt(i);
+ if (c < 128) len += 1;
+ else if (c < 2048) len += 2;
+ else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) {
+ ++i;
+ len += 4;
+ } else len += 3;
+ }
+ return len;
+ };
+ /**
+ * Reads UTF8 bytes as a string.
+ * @param {Uint8Array} buffer Source buffer
+ * @param {number} start Source start
+ * @param {number} end Source end
+ * @returns {string} String read
+ */
+ utf8.read = function utf8_read(buffer, start, end) {
+ if (end - start < 1) return "";
+ var str$1 = "";
+ for (var i = start; i < end;) {
+ var t = buffer[i++];
+ if (t <= 127) str$1 += String.fromCharCode(t);
+ else if (t >= 192 && t < 224) {
+ var c2 = (t & 31) << 6 | buffer[i++] & 63;
+ str$1 += c2 >= 128 ? String.fromCharCode(c2) : replacementChar;
+ } else if (t >= 224 && t < 240) {
+ var c3 = (t & 15) << 12 | (buffer[i++] & 63) << 6 | buffer[i++] & 63;
+ str$1 += c3 >= 2048 ? String.fromCharCode(c3) : replacementChar;
+ } else if (t >= 240) {
+ var t2 = (t & 7) << 18 | (buffer[i++] & 63) << 12 | (buffer[i++] & 63) << 6 | buffer[i++] & 63;
+ if (t2 < 65536 || t2 > 1114111) str$1 += replacementChar;
+ else {
+ t2 -= 65536;
+ str$1 += String.fromCharCode(55296 + (t2 >> 10));
+ str$1 += String.fromCharCode(56320 + (t2 & 1023));
+ }
+ }
+ }
+ return str$1;
+ };
+ /**
+ * Writes a string as UTF8 bytes.
+ * @param {string} string Source string
+ * @param {Uint8Array} buffer Destination buffer
+ * @param {number} offset Destination offset
+ * @returns {number} Bytes written
+ */
+ utf8.write = function utf8_write(string, buffer, offset) {
+ var start = offset, c1, c2;
+ for (var i = 0; i < string.length; ++i) {
+ c1 = string.charCodeAt(i);
+ if (c1 < 128) buffer[offset++] = c1;
+ else if (c1 < 2048) {
+ buffer[offset++] = c1 >> 6 | 192;
+ buffer[offset++] = c1 & 63 | 128;
+ } else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) {
+ c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+ ++i;
+ buffer[offset++] = c1 >> 18 | 240;
+ buffer[offset++] = c1 >> 12 & 63 | 128;
+ buffer[offset++] = c1 >> 6 & 63 | 128;
+ buffer[offset++] = c1 & 63 | 128;
+ } else {
+ buffer[offset++] = c1 >> 12 | 224;
+ buffer[offset++] = c1 >> 6 & 63 | 128;
+ buffer[offset++] = c1 & 63 | 128;
+ }
+ }
+ return offset - start;
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@protobufjs+pool@1.1.0/node_modules/@protobufjs/pool/index.js
+var require_pool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = pool;
+ /**
+ * An allocator as used by {@link util.pool}.
+ * @typedef PoolAllocator
+ * @type {function}
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+ /**
+ * A slicer as used by {@link util.pool}.
+ * @typedef PoolSlicer
+ * @type {function}
+ * @param {number} start Start offset
+ * @param {number} end End offset
+ * @returns {Uint8Array} Buffer slice
+ * @this {Uint8Array}
+ */
+ /**
+ * A general purpose buffer pool.
+ * @memberof util
+ * @function
+ * @param {PoolAllocator} alloc Allocator
+ * @param {PoolSlicer} slice Slicer
+ * @param {number} [size=8192] Slab size
+ * @returns {PoolAllocator} Pooled allocator
+ */
+ function pool(alloc, slice, size) {
+ var SIZE = size || 8192;
+ var MAX = SIZE >>> 1;
+ var slab = null;
+ var offset = SIZE;
+ return function pool_alloc(size$1) {
+ if (size$1 < 1 || size$1 > MAX) return alloc(size$1);
+ if (offset + size$1 > SIZE) {
+ slab = alloc(SIZE);
+ offset = 0;
+ }
+ var buf = slice.call(slab, offset, offset += size$1);
+ if (offset & 7) offset = (offset | 7) + 1;
+ return buf;
+ };
+ }
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/util/longbits.js
+var require_longbits = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = LongBits;
+ var util = require_minimal$1();
+ /**
+ * Constructs new long bits.
+ * @classdesc Helper class for working with the low and high bits of a 64 bit value.
+ * @memberof util
+ * @constructor
+ * @param {number} lo Low 32 bits, unsigned
+ * @param {number} hi High 32 bits, unsigned
+ */
+ function LongBits(lo, hi) {
+ /**
+ * Low bits.
+ * @type {number}
+ */
+ this.lo = lo >>> 0;
+ /**
+ * High bits.
+ * @type {number}
+ */
+ this.hi = hi >>> 0;
+ }
+ /**
+ * Zero bits.
+ * @memberof util.LongBits
+ * @type {util.LongBits}
+ */
+ var zero = LongBits.zero = new LongBits(0, 0);
+ zero.toNumber = function() {
+ return 0;
+ };
+ zero.zzEncode = zero.zzDecode = function() {
+ return this;
+ };
+ zero.length = function() {
+ return 1;
+ };
+ /**
+ * Zero hash.
+ * @memberof util.LongBits
+ * @type {string}
+ */
+ var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
+ /**
+ * Constructs new long bits from the specified number.
+ * @param {number} value Value
+ * @returns {util.LongBits} Instance
+ */
+ LongBits.fromNumber = function fromNumber(value) {
+ if (value === 0) return zero;
+ var sign = value < 0;
+ if (sign) value = -value;
+ var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
+ if (sign) {
+ hi = ~hi >>> 0;
+ lo = ~lo >>> 0;
+ if (++lo > 4294967295) {
+ lo = 0;
+ if (++hi > 4294967295) hi = 0;
+ }
+ }
+ return new LongBits(lo, hi);
+ };
+ /**
+ * Constructs new long bits from a number, long or string.
+ * @param {Long|number|string} value Value
+ * @returns {util.LongBits} Instance
+ */
+ LongBits.from = function from(value) {
+ if (typeof value === "number") return LongBits.fromNumber(value);
+ if (util.isString(value))
+ /* istanbul ignore else */
+ if (util.Long) value = util.Long.fromString(value);
+ else return LongBits.fromNumber(parseInt(value, 10));
+ return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+ };
+ /**
+ * Converts this long bits to a possibly unsafe JavaScript number.
+ * @param {boolean} [unsigned=false] Whether unsigned or not
+ * @returns {number} Possibly unsafe number
+ */
+ LongBits.prototype.toNumber = function toNumber(unsigned) {
+ if (!unsigned && this.hi >>> 31) {
+ var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0;
+ if (!lo) hi = hi + 1 >>> 0;
+ return -(lo + hi * 4294967296);
+ }
+ return this.lo + this.hi * 4294967296;
+ };
+ /**
+ * Converts this long bits to a long.
+ * @param {boolean} [unsigned=false] Whether unsigned or not
+ * @returns {Long} Long
+ */
+ LongBits.prototype.toLong = function toLong(unsigned) {
+ return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : {
+ low: this.lo | 0,
+ high: this.hi | 0,
+ unsigned: Boolean(unsigned)
+ };
+ };
+ var charCodeAt = String.prototype.charCodeAt;
+ /**
+ * Constructs new long bits from the specified 8 characters long hash.
+ * @param {string} hash Hash
+ * @returns {util.LongBits} Bits
+ */
+ LongBits.fromHash = function fromHash(hash) {
+ if (hash === zeroHash) return zero;
+ return new LongBits((charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0, (charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0);
+ };
+ /**
+ * Converts this long bits to a 8 characters long hash.
+ * @returns {string} Hash
+ */
+ LongBits.prototype.toHash = function toHash() {
+ return String.fromCharCode(this.lo & 255, this.lo >>> 8 & 255, this.lo >>> 16 & 255, this.lo >>> 24, this.hi & 255, this.hi >>> 8 & 255, this.hi >>> 16 & 255, this.hi >>> 24);
+ };
+ /**
+ * Zig-zag encodes this long bits.
+ * @returns {util.LongBits} `this`
+ */
+ LongBits.prototype.zzEncode = function zzEncode() {
+ var mask = this.hi >> 31;
+ this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+ this.lo = (this.lo << 1 ^ mask) >>> 0;
+ return this;
+ };
+ /**
+ * Zig-zag decodes this long bits.
+ * @returns {util.LongBits} `this`
+ */
+ LongBits.prototype.zzDecode = function zzDecode() {
+ var mask = -(this.lo & 1);
+ this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+ this.hi = (this.hi >>> 1 ^ mask) >>> 0;
+ return this;
+ };
+ /**
+ * Calculates the length of this longbits when encoded as a varint.
+ * @returns {number} Length
+ */
+ LongBits.prototype.length = function length() {
+ var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24;
+ return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/long@5.3.2/node_modules/long/umd/index.js
+var require_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ (function(global$1, factory) {
+ function preferDefault(exports$1) {
+ return exports$1.default || exports$1;
+ }
+ if (typeof define === "function" && define.amd) define([], function() {
+ var exports$1 = {};
+ factory(exports$1);
+ return preferDefault(exports$1);
+ });
+ else if (typeof exports === "object") {
+ factory(exports);
+ if (typeof module === "object") module.exports = preferDefault(exports);
+ } else (function() {
+ var exports$1 = {};
+ factory(exports$1);
+ global$1.Long = preferDefault(exports$1);
+ })();
+ })(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : exports, function(_exports) {
+ "use strict";
+ Object.defineProperty(_exports, "__esModule", { value: true });
+ _exports.default = void 0;
+ /**
+ * @license
+ * Copyright 2009 The Closure Library Authors
+ * Copyright 2020 Daniel Wirtz / The long.js Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+ var wasm = null;
+ try {
+ wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
+ 0,
+ 97,
+ 115,
+ 109,
+ 1,
+ 0,
+ 0,
+ 0,
+ 1,
+ 13,
+ 2,
+ 96,
+ 0,
+ 1,
+ 127,
+ 96,
+ 4,
+ 127,
+ 127,
+ 127,
+ 127,
+ 1,
+ 127,
+ 3,
+ 7,
+ 6,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 6,
+ 6,
+ 1,
+ 127,
+ 1,
+ 65,
+ 0,
+ 11,
+ 7,
+ 50,
+ 6,
+ 3,
+ 109,
+ 117,
+ 108,
+ 0,
+ 1,
+ 5,
+ 100,
+ 105,
+ 118,
+ 95,
+ 115,
+ 0,
+ 2,
+ 5,
+ 100,
+ 105,
+ 118,
+ 95,
+ 117,
+ 0,
+ 3,
+ 5,
+ 114,
+ 101,
+ 109,
+ 95,
+ 115,
+ 0,
+ 4,
+ 5,
+ 114,
+ 101,
+ 109,
+ 95,
+ 117,
+ 0,
+ 5,
+ 8,
+ 103,
+ 101,
+ 116,
+ 95,
+ 104,
+ 105,
+ 103,
+ 104,
+ 0,
+ 0,
+ 10,
+ 191,
+ 1,
+ 6,
+ 4,
+ 0,
+ 35,
+ 0,
+ 11,
+ 36,
+ 1,
+ 1,
+ 126,
+ 32,
+ 0,
+ 173,
+ 32,
+ 1,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 32,
+ 2,
+ 173,
+ 32,
+ 3,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 126,
+ 34,
+ 4,
+ 66,
+ 32,
+ 135,
+ 167,
+ 36,
+ 0,
+ 32,
+ 4,
+ 167,
+ 11,
+ 36,
+ 1,
+ 1,
+ 126,
+ 32,
+ 0,
+ 173,
+ 32,
+ 1,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 32,
+ 2,
+ 173,
+ 32,
+ 3,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 127,
+ 34,
+ 4,
+ 66,
+ 32,
+ 135,
+ 167,
+ 36,
+ 0,
+ 32,
+ 4,
+ 167,
+ 11,
+ 36,
+ 1,
+ 1,
+ 126,
+ 32,
+ 0,
+ 173,
+ 32,
+ 1,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 32,
+ 2,
+ 173,
+ 32,
+ 3,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 128,
+ 34,
+ 4,
+ 66,
+ 32,
+ 135,
+ 167,
+ 36,
+ 0,
+ 32,
+ 4,
+ 167,
+ 11,
+ 36,
+ 1,
+ 1,
+ 126,
+ 32,
+ 0,
+ 173,
+ 32,
+ 1,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 32,
+ 2,
+ 173,
+ 32,
+ 3,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 129,
+ 34,
+ 4,
+ 66,
+ 32,
+ 135,
+ 167,
+ 36,
+ 0,
+ 32,
+ 4,
+ 167,
+ 11,
+ 36,
+ 1,
+ 1,
+ 126,
+ 32,
+ 0,
+ 173,
+ 32,
+ 1,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 32,
+ 2,
+ 173,
+ 32,
+ 3,
+ 173,
+ 66,
+ 32,
+ 134,
+ 132,
+ 130,
+ 34,
+ 4,
+ 66,
+ 32,
+ 135,
+ 167,
+ 36,
+ 0,
+ 32,
+ 4,
+ 167,
+ 11
+ ])), {}).exports;
+ } catch {}
+ /**
+ * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.
+ * See the from* functions below for more convenient ways of constructing Longs.
+ * @exports Long
+ * @class A Long class for representing a 64 bit two's-complement integer value.
+ * @param {number} low The low (signed) 32 bits of the long
+ * @param {number} high The high (signed) 32 bits of the long
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @constructor
+ */
+ function Long(low, high, unsigned) {
+ /**
+ * The low 32 bits as a signed value.
+ * @type {number}
+ */
+ this.low = low | 0;
+ /**
+ * The high 32 bits as a signed value.
+ * @type {number}
+ */
+ this.high = high | 0;
+ /**
+ * Whether unsigned or not.
+ * @type {boolean}
+ */
+ this.unsigned = !!unsigned;
+ }
+ /**
+ * An indicator used to reliably determine if an object is a Long or not.
+ * @type {boolean}
+ * @const
+ * @private
+ */
+ Long.prototype.__isLong__;
+ Object.defineProperty(Long.prototype, "__isLong__", { value: true });
+ /**
+ * @function
+ * @param {*} obj Object
+ * @returns {boolean}
+ * @inner
+ */
+ function isLong(obj) {
+ return (obj && obj["__isLong__"]) === true;
+ }
+ /**
+ * @function
+ * @param {*} value number
+ * @returns {number}
+ * @inner
+ */
+ function ctz32(value) {
+ var c = Math.clz32(value & -value);
+ return value ? 31 - c : c;
+ }
+ /**
+ * Tests if the specified object is a Long.
+ * @function
+ * @param {*} obj Object
+ * @returns {boolean}
+ */
+ Long.isLong = isLong;
+ /**
+ * A cache of the Long representations of small integer values.
+ * @type {!Object}
+ * @inner
+ */
+ var INT_CACHE = {};
+ /**
+ * A cache of the Long representations of small unsigned integer values.
+ * @type {!Object}
+ * @inner
+ */
+ var UINT_CACHE = {};
+ /**
+ * @param {number} value
+ * @param {boolean=} unsigned
+ * @returns {!Long}
+ * @inner
+ */
+ function fromInt(value, unsigned) {
+ var obj, cachedObj, cache;
+ if (unsigned) {
+ value >>>= 0;
+ if (cache = 0 <= value && value < 256) {
+ cachedObj = UINT_CACHE[value];
+ if (cachedObj) return cachedObj;
+ }
+ obj = fromBits(value, 0, true);
+ if (cache) UINT_CACHE[value] = obj;
+ return obj;
+ } else {
+ value |= 0;
+ if (cache = -128 <= value && value < 128) {
+ cachedObj = INT_CACHE[value];
+ if (cachedObj) return cachedObj;
+ }
+ obj = fromBits(value, value < 0 ? -1 : 0, false);
+ if (cache) INT_CACHE[value] = obj;
+ return obj;
+ }
+ }
+ /**
+ * Returns a Long representing the given 32 bit integer value.
+ * @function
+ * @param {number} value The 32 bit integer in question
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @returns {!Long} The corresponding Long value
+ */
+ Long.fromInt = fromInt;
+ /**
+ * @param {number} value
+ * @param {boolean=} unsigned
+ * @returns {!Long}
+ * @inner
+ */
+ function fromNumber(value, unsigned) {
+ if (isNaN(value)) return unsigned ? UZERO : ZERO;
+ if (unsigned) {
+ if (value < 0) return UZERO;
+ if (value >= TWO_PWR_64_DBL) return MAX_UNSIGNED_VALUE;
+ } else {
+ if (value <= -TWO_PWR_63_DBL) return MIN_VALUE;
+ if (value + 1 >= TWO_PWR_63_DBL) return MAX_VALUE;
+ }
+ if (value < 0) return fromNumber(-value, unsigned).neg();
+ return fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
+ }
+ /**
+ * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
+ * @function
+ * @param {number} value The number in question
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @returns {!Long} The corresponding Long value
+ */
+ Long.fromNumber = fromNumber;
+ /**
+ * @param {number} lowBits
+ * @param {number} highBits
+ * @param {boolean=} unsigned
+ * @returns {!Long}
+ * @inner
+ */
+ function fromBits(lowBits, highBits, unsigned) {
+ return new Long(lowBits, highBits, unsigned);
+ }
+ /**
+ * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is
+ * assumed to use 32 bits.
+ * @function
+ * @param {number} lowBits The low 32 bits
+ * @param {number} highBits The high 32 bits
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @returns {!Long} The corresponding Long value
+ */
+ Long.fromBits = fromBits;
+ /**
+ * @function
+ * @param {number} base
+ * @param {number} exponent
+ * @returns {number}
+ * @inner
+ */
+ var pow_dbl = Math.pow;
+ /**
+ * @param {string} str
+ * @param {(boolean|number)=} unsigned
+ * @param {number=} radix
+ * @returns {!Long}
+ * @inner
+ */
+ function fromString(str$1, unsigned, radix) {
+ if (str$1.length === 0) throw Error("empty string");
+ if (typeof unsigned === "number") {
+ radix = unsigned;
+ unsigned = false;
+ } else unsigned = !!unsigned;
+ if (str$1 === "NaN" || str$1 === "Infinity" || str$1 === "+Infinity" || str$1 === "-Infinity") return unsigned ? UZERO : ZERO;
+ radix = radix || 10;
+ if (radix < 2 || 36 < radix) throw RangeError("radix");
+ var p;
+ if ((p = str$1.indexOf("-")) > 0) throw Error("interior hyphen");
+ else if (p === 0) return fromString(str$1.substring(1), unsigned, radix).neg();
+ var radixToPower = fromNumber(pow_dbl(radix, 8));
+ var result = ZERO;
+ for (var i = 0; i < str$1.length; i += 8) {
+ var size = Math.min(8, str$1.length - i), value = parseInt(str$1.substring(i, i + size), radix);
+ if (size < 8) {
+ var power = fromNumber(pow_dbl(radix, size));
+ result = result.mul(power).add(fromNumber(value));
+ } else {
+ result = result.mul(radixToPower);
+ result = result.add(fromNumber(value));
+ }
+ }
+ result.unsigned = unsigned;
+ return result;
+ }
+ /**
+ * Returns a Long representation of the given string, written using the specified radix.
+ * @function
+ * @param {string} str The textual representation of the Long
+ * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed
+ * @param {number=} radix The radix in which the text is written (2-36), defaults to 10
+ * @returns {!Long} The corresponding Long value
+ */
+ Long.fromString = fromString;
+ /**
+ * @function
+ * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val
+ * @param {boolean=} unsigned
+ * @returns {!Long}
+ * @inner
+ */
+ function fromValue(val, unsigned) {
+ if (typeof val === "number") return fromNumber(val, unsigned);
+ if (typeof val === "string") return fromString(val, unsigned);
+ return fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned);
+ }
+ /**
+ * Converts the specified value to a Long using the appropriate from* function for its type.
+ * @function
+ * @param {!Long|number|bigint|string|!{low: number, high: number, unsigned: boolean}} val Value
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @returns {!Long}
+ */
+ Long.fromValue = fromValue;
+ /**
+ * @type {number}
+ * @const
+ * @inner
+ */
+ var TWO_PWR_16_DBL = 65536;
+ /**
+ * @type {number}
+ * @const
+ * @inner
+ */
+ var TWO_PWR_24_DBL = 1 << 24;
+ /**
+ * @type {number}
+ * @const
+ * @inner
+ */
+ var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
+ /**
+ * @type {number}
+ * @const
+ * @inner
+ */
+ var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
+ /**
+ * @type {number}
+ * @const
+ * @inner
+ */
+ var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
+ /**
+ * @type {!Long}
+ * @const
+ * @inner
+ */
+ var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
+ /**
+ * @type {!Long}
+ * @inner
+ */
+ var ZERO = fromInt(0);
+ /**
+ * Signed zero.
+ * @type {!Long}
+ */
+ Long.ZERO = ZERO;
+ /**
+ * @type {!Long}
+ * @inner
+ */
+ var UZERO = fromInt(0, true);
+ /**
+ * Unsigned zero.
+ * @type {!Long}
+ */
+ Long.UZERO = UZERO;
+ /**
+ * @type {!Long}
+ * @inner
+ */
+ var ONE = fromInt(1);
+ /**
+ * Signed one.
+ * @type {!Long}
+ */
+ Long.ONE = ONE;
+ /**
+ * @type {!Long}
+ * @inner
+ */
+ var UONE = fromInt(1, true);
+ /**
+ * Unsigned one.
+ * @type {!Long}
+ */
+ Long.UONE = UONE;
+ /**
+ * @type {!Long}
+ * @inner
+ */
+ var NEG_ONE = fromInt(-1);
+ /**
+ * Signed negative one.
+ * @type {!Long}
+ */
+ Long.NEG_ONE = NEG_ONE;
+ /**
+ * @type {!Long}
+ * @inner
+ */
+ var MAX_VALUE = fromBits(-1, 2147483647, false);
+ /**
+ * Maximum signed value.
+ * @type {!Long}
+ */
+ Long.MAX_VALUE = MAX_VALUE;
+ /**
+ * @type {!Long}
+ * @inner
+ */
+ var MAX_UNSIGNED_VALUE = fromBits(-1, -1, true);
+ /**
+ * Maximum unsigned value.
+ * @type {!Long}
+ */
+ Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
+ /**
+ * @type {!Long}
+ * @inner
+ */
+ var MIN_VALUE = fromBits(0, -2147483648, false);
+ /**
+ * Minimum signed value.
+ * @type {!Long}
+ */
+ Long.MIN_VALUE = MIN_VALUE;
+ /**
+ * @alias Long.prototype
+ * @inner
+ */
+ var LongPrototype = Long.prototype;
+ /**
+ * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
+ * @this {!Long}
+ * @returns {number}
+ */
+ LongPrototype.toInt = function toInt() {
+ return this.unsigned ? this.low >>> 0 : this.low;
+ };
+ /**
+ * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).
+ * @this {!Long}
+ * @returns {number}
+ */
+ LongPrototype.toNumber = function toNumber() {
+ if (this.unsigned) return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
+ return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
+ };
+ /**
+ * Converts the Long to a string written in the specified radix.
+ * @this {!Long}
+ * @param {number=} radix Radix (2-36), defaults to 10
+ * @returns {string}
+ * @override
+ * @throws {RangeError} If `radix` is out of range
+ */
+ LongPrototype.toString = function toString(radix) {
+ radix = radix || 10;
+ if (radix < 2 || 36 < radix) throw RangeError("radix");
+ if (this.isZero()) return "0";
+ if (this.isNegative()) if (this.eq(MIN_VALUE)) {
+ var radixLong = fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this);
+ return div.toString(radix) + rem1.toInt().toString(radix);
+ } else return "-" + this.neg().toString(radix);
+ var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this;
+ var result = "";
+ while (true) {
+ var remDiv = rem.div(radixToPower), digits = (rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0).toString(radix);
+ rem = remDiv;
+ if (rem.isZero()) return digits + result;
+ else {
+ while (digits.length < 6) digits = "0" + digits;
+ result = "" + digits + result;
+ }
+ }
+ };
+ /**
+ * Gets the high 32 bits as a signed integer.
+ * @this {!Long}
+ * @returns {number} Signed high bits
+ */
+ LongPrototype.getHighBits = function getHighBits() {
+ return this.high;
+ };
+ /**
+ * Gets the high 32 bits as an unsigned integer.
+ * @this {!Long}
+ * @returns {number} Unsigned high bits
+ */
+ LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
+ return this.high >>> 0;
+ };
+ /**
+ * Gets the low 32 bits as a signed integer.
+ * @this {!Long}
+ * @returns {number} Signed low bits
+ */
+ LongPrototype.getLowBits = function getLowBits() {
+ return this.low;
+ };
+ /**
+ * Gets the low 32 bits as an unsigned integer.
+ * @this {!Long}
+ * @returns {number} Unsigned low bits
+ */
+ LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
+ return this.low >>> 0;
+ };
+ /**
+ * Gets the number of bits needed to represent the absolute value of this Long.
+ * @this {!Long}
+ * @returns {number}
+ */
+ LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
+ if (this.isNegative()) return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
+ var val = this.high != 0 ? this.high : this.low;
+ for (var bit = 31; bit > 0; bit--) if ((val & 1 << bit) != 0) break;
+ return this.high != 0 ? bit + 33 : bit + 1;
+ };
+ /**
+ * Tests if this Long can be safely represented as a JavaScript number.
+ * @this {!Long}
+ * @returns {boolean}
+ */
+ LongPrototype.isSafeInteger = function isSafeInteger() {
+ var top11Bits = this.high >> 21;
+ if (!top11Bits) return true;
+ if (this.unsigned) return false;
+ return top11Bits === -1 && !(this.low === 0 && this.high === -2097152);
+ };
+ /**
+ * Tests if this Long's value equals zero.
+ * @this {!Long}
+ * @returns {boolean}
+ */
+ LongPrototype.isZero = function isZero() {
+ return this.high === 0 && this.low === 0;
+ };
+ /**
+ * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.
+ * @returns {boolean}
+ */
+ LongPrototype.eqz = LongPrototype.isZero;
+ /**
+ * Tests if this Long's value is negative.
+ * @this {!Long}
+ * @returns {boolean}
+ */
+ LongPrototype.isNegative = function isNegative() {
+ return !this.unsigned && this.high < 0;
+ };
+ /**
+ * Tests if this Long's value is positive or zero.
+ * @this {!Long}
+ * @returns {boolean}
+ */
+ LongPrototype.isPositive = function isPositive() {
+ return this.unsigned || this.high >= 0;
+ };
+ /**
+ * Tests if this Long's value is odd.
+ * @this {!Long}
+ * @returns {boolean}
+ */
+ LongPrototype.isOdd = function isOdd() {
+ return (this.low & 1) === 1;
+ };
+ /**
+ * Tests if this Long's value is even.
+ * @this {!Long}
+ * @returns {boolean}
+ */
+ LongPrototype.isEven = function isEven() {
+ return (this.low & 1) === 0;
+ };
+ /**
+ * Tests if this Long's value equals the specified's.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.equals = function equals(other) {
+ if (!isLong(other)) other = fromValue(other);
+ if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1) return false;
+ return this.high === other.high && this.low === other.low;
+ };
+ /**
+ * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.eq = LongPrototype.equals;
+ /**
+ * Tests if this Long's value differs from the specified's.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.notEquals = function notEquals(other) {
+ return !this.eq(other);
+ };
+ /**
+ * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.neq = LongPrototype.notEquals;
+ /**
+ * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.ne = LongPrototype.notEquals;
+ /**
+ * Tests if this Long's value is less than the specified's.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.lessThan = function lessThan(other) {
+ return this.comp(other) < 0;
+ };
+ /**
+ * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.lt = LongPrototype.lessThan;
+ /**
+ * Tests if this Long's value is less than or equal the specified's.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
+ return this.comp(other) <= 0;
+ };
+ /**
+ * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.lte = LongPrototype.lessThanOrEqual;
+ /**
+ * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.le = LongPrototype.lessThanOrEqual;
+ /**
+ * Tests if this Long's value is greater than the specified's.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.greaterThan = function greaterThan(other) {
+ return this.comp(other) > 0;
+ };
+ /**
+ * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.gt = LongPrototype.greaterThan;
+ /**
+ * Tests if this Long's value is greater than or equal the specified's.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
+ return this.comp(other) >= 0;
+ };
+ /**
+ * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.gte = LongPrototype.greaterThanOrEqual;
+ /**
+ * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {boolean}
+ */
+ LongPrototype.ge = LongPrototype.greaterThanOrEqual;
+ /**
+ * Compares this Long's value with the specified's.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {number} 0 if they are the same, 1 if the this is greater and -1
+ * if the given one is greater
+ */
+ LongPrototype.compare = function compare(other) {
+ if (!isLong(other)) other = fromValue(other);
+ if (this.eq(other)) return 0;
+ var thisNeg = this.isNegative(), otherNeg = other.isNegative();
+ if (thisNeg && !otherNeg) return -1;
+ if (!thisNeg && otherNeg) return 1;
+ if (!this.unsigned) return this.sub(other).isNegative() ? -1 : 1;
+ return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
+ };
+ /**
+ * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.
+ * @function
+ * @param {!Long|number|bigint|string} other Other value
+ * @returns {number} 0 if they are the same, 1 if the this is greater and -1
+ * if the given one is greater
+ */
+ LongPrototype.comp = LongPrototype.compare;
+ /**
+ * Negates this Long's value.
+ * @this {!Long}
+ * @returns {!Long} Negated Long
+ */
+ LongPrototype.negate = function negate() {
+ if (!this.unsigned && this.eq(MIN_VALUE)) return MIN_VALUE;
+ return this.not().add(ONE);
+ };
+ /**
+ * Negates this Long's value. This is an alias of {@link Long#negate}.
+ * @function
+ * @returns {!Long} Negated Long
+ */
+ LongPrototype.neg = LongPrototype.negate;
+ /**
+ * Returns the sum of this and the specified Long.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} addend Addend
+ * @returns {!Long} Sum
+ */
+ LongPrototype.add = function add(addend) {
+ if (!isLong(addend)) addend = fromValue(addend);
+ var a48 = this.high >>> 16;
+ var a32 = this.high & 65535;
+ var a16 = this.low >>> 16;
+ var a00 = this.low & 65535;
+ var b48 = addend.high >>> 16;
+ var b32 = addend.high & 65535;
+ var b16 = addend.low >>> 16;
+ var b00 = addend.low & 65535;
+ var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+ c00 += a00 + b00;
+ c16 += c00 >>> 16;
+ c00 &= 65535;
+ c16 += a16 + b16;
+ c32 += c16 >>> 16;
+ c16 &= 65535;
+ c32 += a32 + b32;
+ c48 += c32 >>> 16;
+ c32 &= 65535;
+ c48 += a48 + b48;
+ c48 &= 65535;
+ return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+ };
+ /**
+ * Returns the difference of this and the specified Long.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} subtrahend Subtrahend
+ * @returns {!Long} Difference
+ */
+ LongPrototype.subtract = function subtract(subtrahend) {
+ if (!isLong(subtrahend)) subtrahend = fromValue(subtrahend);
+ return this.add(subtrahend.neg());
+ };
+ /**
+ * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.
+ * @function
+ * @param {!Long|number|bigint|string} subtrahend Subtrahend
+ * @returns {!Long} Difference
+ */
+ LongPrototype.sub = LongPrototype.subtract;
+ /**
+ * Returns the product of this and the specified Long.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} multiplier Multiplier
+ * @returns {!Long} Product
+ */
+ LongPrototype.multiply = function multiply(multiplier) {
+ if (this.isZero()) return this;
+ if (!isLong(multiplier)) multiplier = fromValue(multiplier);
+ if (wasm) return fromBits(wasm["mul"](this.low, this.high, multiplier.low, multiplier.high), wasm["get_high"](), this.unsigned);
+ if (multiplier.isZero()) return this.unsigned ? UZERO : ZERO;
+ if (this.eq(MIN_VALUE)) return multiplier.isOdd() ? MIN_VALUE : ZERO;
+ if (multiplier.eq(MIN_VALUE)) return this.isOdd() ? MIN_VALUE : ZERO;
+ if (this.isNegative()) if (multiplier.isNegative()) return this.neg().mul(multiplier.neg());
+ else return this.neg().mul(multiplier).neg();
+ else if (multiplier.isNegative()) return this.mul(multiplier.neg()).neg();
+ if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24)) return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
+ var a48 = this.high >>> 16;
+ var a32 = this.high & 65535;
+ var a16 = this.low >>> 16;
+ var a00 = this.low & 65535;
+ var b48 = multiplier.high >>> 16;
+ var b32 = multiplier.high & 65535;
+ var b16 = multiplier.low >>> 16;
+ var b00 = multiplier.low & 65535;
+ var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+ c00 += a00 * b00;
+ c16 += c00 >>> 16;
+ c00 &= 65535;
+ c16 += a16 * b00;
+ c32 += c16 >>> 16;
+ c16 &= 65535;
+ c16 += a00 * b16;
+ c32 += c16 >>> 16;
+ c16 &= 65535;
+ c32 += a32 * b00;
+ c48 += c32 >>> 16;
+ c32 &= 65535;
+ c32 += a16 * b16;
+ c48 += c32 >>> 16;
+ c32 &= 65535;
+ c32 += a00 * b32;
+ c48 += c32 >>> 16;
+ c32 &= 65535;
+ c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+ c48 &= 65535;
+ return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+ };
+ /**
+ * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.
+ * @function
+ * @param {!Long|number|bigint|string} multiplier Multiplier
+ * @returns {!Long} Product
+ */
+ LongPrototype.mul = LongPrototype.multiply;
+ /**
+ * Returns this Long divided by the specified. The result is signed if this Long is signed or
+ * unsigned if this Long is unsigned.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} divisor Divisor
+ * @returns {!Long} Quotient
+ */
+ LongPrototype.divide = function divide(divisor) {
+ if (!isLong(divisor)) divisor = fromValue(divisor);
+ if (divisor.isZero()) throw Error("division by zero");
+ if (wasm) {
+ if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) return this;
+ return fromBits((this.unsigned ? wasm["div_u"] : wasm["div_s"])(this.low, this.high, divisor.low, divisor.high), wasm["get_high"](), this.unsigned);
+ }
+ if (this.isZero()) return this.unsigned ? UZERO : ZERO;
+ var approx, rem, res;
+ if (!this.unsigned) {
+ if (this.eq(MIN_VALUE)) if (divisor.eq(ONE) || divisor.eq(NEG_ONE)) return MIN_VALUE;
+ else if (divisor.eq(MIN_VALUE)) return ONE;
+ else {
+ approx = this.shr(1).div(divisor).shl(1);
+ if (approx.eq(ZERO)) return divisor.isNegative() ? ONE : NEG_ONE;
+ else {
+ rem = this.sub(divisor.mul(approx));
+ res = approx.add(rem.div(divisor));
+ return res;
+ }
+ }
+ else if (divisor.eq(MIN_VALUE)) return this.unsigned ? UZERO : ZERO;
+ if (this.isNegative()) {
+ if (divisor.isNegative()) return this.neg().div(divisor.neg());
+ return this.neg().div(divisor).neg();
+ } else if (divisor.isNegative()) return this.div(divisor.neg()).neg();
+ res = ZERO;
+ } else {
+ if (!divisor.unsigned) divisor = divisor.toUnsigned();
+ if (divisor.gt(this)) return UZERO;
+ if (divisor.gt(this.shru(1))) return UONE;
+ res = UZERO;
+ }
+ rem = this;
+ while (rem.gte(divisor)) {
+ approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
+ var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor);
+ while (approxRem.isNegative() || approxRem.gt(rem)) {
+ approx -= delta;
+ approxRes = fromNumber(approx, this.unsigned);
+ approxRem = approxRes.mul(divisor);
+ }
+ if (approxRes.isZero()) approxRes = ONE;
+ res = res.add(approxRes);
+ rem = rem.sub(approxRem);
+ }
+ return res;
+ };
+ /**
+ * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.
+ * @function
+ * @param {!Long|number|bigint|string} divisor Divisor
+ * @returns {!Long} Quotient
+ */
+ LongPrototype.div = LongPrototype.divide;
+ /**
+ * Returns this Long modulo the specified.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} divisor Divisor
+ * @returns {!Long} Remainder
+ */
+ LongPrototype.modulo = function modulo(divisor) {
+ if (!isLong(divisor)) divisor = fromValue(divisor);
+ if (wasm) return fromBits((this.unsigned ? wasm["rem_u"] : wasm["rem_s"])(this.low, this.high, divisor.low, divisor.high), wasm["get_high"](), this.unsigned);
+ return this.sub(this.div(divisor).mul(divisor));
+ };
+ /**
+ * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.
+ * @function
+ * @param {!Long|number|bigint|string} divisor Divisor
+ * @returns {!Long} Remainder
+ */
+ LongPrototype.mod = LongPrototype.modulo;
+ /**
+ * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.
+ * @function
+ * @param {!Long|number|bigint|string} divisor Divisor
+ * @returns {!Long} Remainder
+ */
+ LongPrototype.rem = LongPrototype.modulo;
+ /**
+ * Returns the bitwise NOT of this Long.
+ * @this {!Long}
+ * @returns {!Long}
+ */
+ LongPrototype.not = function not() {
+ return fromBits(~this.low, ~this.high, this.unsigned);
+ };
+ /**
+ * Returns count leading zeros of this Long.
+ * @this {!Long}
+ * @returns {!number}
+ */
+ LongPrototype.countLeadingZeros = function countLeadingZeros() {
+ return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;
+ };
+ /**
+ * Returns count leading zeros. This is an alias of {@link Long#countLeadingZeros}.
+ * @function
+ * @param {!Long}
+ * @returns {!number}
+ */
+ LongPrototype.clz = LongPrototype.countLeadingZeros;
+ /**
+ * Returns count trailing zeros of this Long.
+ * @this {!Long}
+ * @returns {!number}
+ */
+ LongPrototype.countTrailingZeros = function countTrailingZeros() {
+ return this.low ? ctz32(this.low) : ctz32(this.high) + 32;
+ };
+ /**
+ * Returns count trailing zeros. This is an alias of {@link Long#countTrailingZeros}.
+ * @function
+ * @param {!Long}
+ * @returns {!number}
+ */
+ LongPrototype.ctz = LongPrototype.countTrailingZeros;
+ /**
+ * Returns the bitwise AND of this Long and the specified.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other Long
+ * @returns {!Long}
+ */
+ LongPrototype.and = function and(other) {
+ if (!isLong(other)) other = fromValue(other);
+ return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
+ };
+ /**
+ * Returns the bitwise OR of this Long and the specified.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other Long
+ * @returns {!Long}
+ */
+ LongPrototype.or = function or(other) {
+ if (!isLong(other)) other = fromValue(other);
+ return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
+ };
+ /**
+ * Returns the bitwise XOR of this Long and the given one.
+ * @this {!Long}
+ * @param {!Long|number|bigint|string} other Other Long
+ * @returns {!Long}
+ */
+ LongPrototype.xor = function xor(other) {
+ if (!isLong(other)) other = fromValue(other);
+ return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
+ };
+ /**
+ * Returns this Long with bits shifted to the left by the given amount.
+ * @this {!Long}
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Shifted Long
+ */
+ LongPrototype.shiftLeft = function shiftLeft(numBits) {
+ if (isLong(numBits)) numBits = numBits.toInt();
+ if ((numBits &= 63) === 0) return this;
+ else if (numBits < 32) return fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned);
+ else return fromBits(0, this.low << numBits - 32, this.unsigned);
+ };
+ /**
+ * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.
+ * @function
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Shifted Long
+ */
+ LongPrototype.shl = LongPrototype.shiftLeft;
+ /**
+ * Returns this Long with bits arithmetically shifted to the right by the given amount.
+ * @this {!Long}
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Shifted Long
+ */
+ LongPrototype.shiftRight = function shiftRight(numBits) {
+ if (isLong(numBits)) numBits = numBits.toInt();
+ if ((numBits &= 63) === 0) return this;
+ else if (numBits < 32) return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned);
+ else return fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+ };
+ /**
+ * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.
+ * @function
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Shifted Long
+ */
+ LongPrototype.shr = LongPrototype.shiftRight;
+ /**
+ * Returns this Long with bits logically shifted to the right by the given amount.
+ * @this {!Long}
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Shifted Long
+ */
+ LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
+ if (isLong(numBits)) numBits = numBits.toInt();
+ if ((numBits &= 63) === 0) return this;
+ if (numBits < 32) return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >>> numBits, this.unsigned);
+ if (numBits === 32) return fromBits(this.high, 0, this.unsigned);
+ return fromBits(this.high >>> numBits - 32, 0, this.unsigned);
+ };
+ /**
+ * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.
+ * @function
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Shifted Long
+ */
+ LongPrototype.shru = LongPrototype.shiftRightUnsigned;
+ /**
+ * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.
+ * @function
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Shifted Long
+ */
+ LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
+ /**
+ * Returns this Long with bits rotated to the left by the given amount.
+ * @this {!Long}
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Rotated Long
+ */
+ LongPrototype.rotateLeft = function rotateLeft(numBits) {
+ var b;
+ if (isLong(numBits)) numBits = numBits.toInt();
+ if ((numBits &= 63) === 0) return this;
+ if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);
+ if (numBits < 32) {
+ b = 32 - numBits;
+ return fromBits(this.low << numBits | this.high >>> b, this.high << numBits | this.low >>> b, this.unsigned);
+ }
+ numBits -= 32;
+ b = 32 - numBits;
+ return fromBits(this.high << numBits | this.low >>> b, this.low << numBits | this.high >>> b, this.unsigned);
+ };
+ /**
+ * Returns this Long with bits rotated to the left by the given amount. This is an alias of {@link Long#rotateLeft}.
+ * @function
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Rotated Long
+ */
+ LongPrototype.rotl = LongPrototype.rotateLeft;
+ /**
+ * Returns this Long with bits rotated to the right by the given amount.
+ * @this {!Long}
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Rotated Long
+ */
+ LongPrototype.rotateRight = function rotateRight(numBits) {
+ var b;
+ if (isLong(numBits)) numBits = numBits.toInt();
+ if ((numBits &= 63) === 0) return this;
+ if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);
+ if (numBits < 32) {
+ b = 32 - numBits;
+ return fromBits(this.high << b | this.low >>> numBits, this.low << b | this.high >>> numBits, this.unsigned);
+ }
+ numBits -= 32;
+ b = 32 - numBits;
+ return fromBits(this.low << b | this.high >>> numBits, this.high << b | this.low >>> numBits, this.unsigned);
+ };
+ /**
+ * Returns this Long with bits rotated to the right by the given amount. This is an alias of {@link Long#rotateRight}.
+ * @function
+ * @param {number|!Long} numBits Number of bits
+ * @returns {!Long} Rotated Long
+ */
+ LongPrototype.rotr = LongPrototype.rotateRight;
+ /**
+ * Converts this Long to signed.
+ * @this {!Long}
+ * @returns {!Long} Signed long
+ */
+ LongPrototype.toSigned = function toSigned() {
+ if (!this.unsigned) return this;
+ return fromBits(this.low, this.high, false);
+ };
+ /**
+ * Converts this Long to unsigned.
+ * @this {!Long}
+ * @returns {!Long} Unsigned long
+ */
+ LongPrototype.toUnsigned = function toUnsigned() {
+ if (this.unsigned) return this;
+ return fromBits(this.low, this.high, true);
+ };
+ /**
+ * Converts this Long to its byte representation.
+ * @param {boolean=} le Whether little or big endian, defaults to big endian
+ * @this {!Long}
+ * @returns {!Array.} Byte representation
+ */
+ LongPrototype.toBytes = function toBytes(le) {
+ return le ? this.toBytesLE() : this.toBytesBE();
+ };
+ /**
+ * Converts this Long to its little endian byte representation.
+ * @this {!Long}
+ * @returns {!Array.} Little endian byte representation
+ */
+ LongPrototype.toBytesLE = function toBytesLE() {
+ var hi = this.high, lo = this.low;
+ return [
+ lo & 255,
+ lo >>> 8 & 255,
+ lo >>> 16 & 255,
+ lo >>> 24,
+ hi & 255,
+ hi >>> 8 & 255,
+ hi >>> 16 & 255,
+ hi >>> 24
+ ];
+ };
+ /**
+ * Converts this Long to its big endian byte representation.
+ * @this {!Long}
+ * @returns {!Array.} Big endian byte representation
+ */
+ LongPrototype.toBytesBE = function toBytesBE() {
+ var hi = this.high, lo = this.low;
+ return [
+ hi >>> 24,
+ hi >>> 16 & 255,
+ hi >>> 8 & 255,
+ hi & 255,
+ lo >>> 24,
+ lo >>> 16 & 255,
+ lo >>> 8 & 255,
+ lo & 255
+ ];
+ };
+ /**
+ * Creates a Long from its byte representation.
+ * @param {!Array.} bytes Byte representation
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @param {boolean=} le Whether little or big endian, defaults to big endian
+ * @returns {Long} The corresponding Long value
+ */
+ Long.fromBytes = function fromBytes(bytes, unsigned, le) {
+ return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
+ };
+ /**
+ * Creates a Long from its little endian byte representation.
+ * @param {!Array.} bytes Little endian byte representation
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @returns {Long} The corresponding Long value
+ */
+ Long.fromBytesLE = function fromBytesLE(bytes, unsigned) {
+ return new Long(bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24, bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24, unsigned);
+ };
+ /**
+ * Creates a Long from its big endian byte representation.
+ * @param {!Array.} bytes Big endian byte representation
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @returns {Long} The corresponding Long value
+ */
+ Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
+ return new Long(bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], unsigned);
+ };
+ if (typeof BigInt === "function") {
+ /**
+ * Returns a Long representing the given big integer.
+ * @function
+ * @param {number} value The big integer value
+ * @param {boolean=} unsigned Whether unsigned or not, defaults to signed
+ * @returns {!Long} The corresponding Long value
+ */
+ Long.fromBigInt = function fromBigInt(value, unsigned) {
+ return fromBits(Number(BigInt.asIntN(32, value)), Number(BigInt.asIntN(32, value >> BigInt(32))), unsigned);
+ };
+ Long.fromValue = function fromValueWithBigInt(value, unsigned) {
+ if (typeof value === "bigint") return Long.fromBigInt(value, unsigned);
+ return fromValue(value, unsigned);
+ };
+ /**
+ * Converts the Long to its big integer representation.
+ * @this {!Long}
+ * @returns {bigint}
+ */
+ LongPrototype.toBigInt = function toBigInt() {
+ var lowBigInt = BigInt(this.low >>> 0);
+ return BigInt(this.unsigned ? this.high >>> 0 : this.high) << BigInt(32) | lowBigInt;
+ };
+ }
+ _exports.default = Long;
+ });
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/util/minimal.js
+var require_minimal$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+ var util = exports;
+ util.asPromise = require_aspromise();
+ util.base64 = require_base64();
+ util.EventEmitter = require_eventemitter();
+ util.float = require_float();
+ util.utf8 = require_utf8();
+ util.pool = require_pool();
+ util.LongBits = require_longbits();
+ /**
+ * Tests if the specified key can affect object prototypes.
+ * @memberof util
+ * @param {string} key Key to test
+ * @returns {boolean} `true` if the key is unsafe
+ */
+ function isUnsafeProperty(key) {
+ return key === "__proto__" || key === "prototype" || key === "constructor";
+ }
+ util.isUnsafeProperty = isUnsafeProperty;
+ /**
+ * Whether running within node or not.
+ * @memberof util
+ * @type {boolean}
+ */
+ util.isNode = Boolean(typeof global !== "undefined" && global && global.process && global.process.versions && global.process.versions.node);
+ /**
+ * Global object reference.
+ * @memberof util
+ * @type {Object}
+ */
+ util.global = util.isNode && global || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports;
+ /**
+ * An immuable empty array.
+ * @memberof util
+ * @type {Array.<*>}
+ * @const
+ */
+ util.emptyArray = Object.freeze ? Object.freeze([]) : [];
+ /**
+ * An immutable empty object.
+ * @type {Object}
+ * @const
+ */
+ util.emptyObject = Object.freeze ? Object.freeze({}) : ( /* istanbul ignore next */ {});
+ /**
+ * Tests if the specified value is an integer.
+ * @function
+ * @param {*} value Value to test
+ * @returns {boolean} `true` if the value is an integer
+ */
+ util.isInteger = Number.isInteger || function isInteger(value) {
+ return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+ };
+ /**
+ * Tests if the specified value is a string.
+ * @param {*} value Value to test
+ * @returns {boolean} `true` if the value is a string
+ */
+ util.isString = function isString(value) {
+ return typeof value === "string" || value instanceof String;
+ };
+ /**
+ * Tests if the specified value is a non-null object.
+ * @param {*} value Value to test
+ * @returns {boolean} `true` if the value is a non-null object
+ */
+ util.isObject = function isObject(value) {
+ return value && typeof value === "object";
+ };
+ /**
+ * Checks if a property on a message is considered to be present.
+ * This is an alias of {@link util.isSet}.
+ * @function
+ * @param {Object} obj Plain object or message instance
+ * @param {string} prop Property name
+ * @returns {boolean} `true` if considered to be present, otherwise `false`
+ */
+ util.isset = util.isSet = function isSet(obj, prop) {
+ var value = obj[prop];
+ if (value != null && Object.hasOwnProperty.call(obj, prop)) return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
+ return false;
+ };
+ /**
+ * Any compatible Buffer instance.
+ * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
+ * @interface Buffer
+ * @extends Uint8Array
+ */
+ /**
+ * Node's Buffer class if available.
+ * @type {Constructor}
+ */
+ util.Buffer = (function() {
+ try {
+ var Buffer$1 = util.global.Buffer;
+ return Buffer$1.prototype.utf8Write ? Buffer$1 : null;
+ } catch (e) {
+ /* istanbul ignore next */
+ return null;
+ }
+ })();
+ util._Buffer_from = null;
+ util._Buffer_allocUnsafe = null;
+ /**
+ * Creates a new buffer of whatever type supported by the environment.
+ * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
+ * @returns {Uint8Array|Buffer} Buffer
+ */
+ util.newBuffer = function newBuffer(sizeOrArray) {
+ /* istanbul ignore next */
+ return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
+ };
+ /**
+ * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
+ * @type {Constructor}
+ */
+ util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+ /**
+ * Any compatible Long instance.
+ * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
+ * @interface Long
+ * @property {number} low Low bits
+ * @property {number} high High bits
+ * @property {boolean} unsigned Whether unsigned or not
+ */
+ /**
+ * Long.js's Long class if available.
+ * @type {Constructor}
+ */
+ util.Long = util.global.dcodeIO && util.global.dcodeIO.Long || util.global.Long || (function() {
+ try {
+ var Long = require_umd();
+ return Long && Long.isLong ? Long : null;
+ } catch (e) {
+ /* istanbul ignore next */
+ return null;
+ }
+ })();
+ /**
+ * Regular expression used to verify 2 bit (`bool`) map keys.
+ * @type {RegExp}
+ * @const
+ */
+ util.key2Re = /^true|false|0|1$/;
+ /**
+ * Regular expression used to verify 32 bit (`int32` etc.) map keys.
+ * @type {RegExp}
+ * @const
+ */
+ util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
+ /**
+ * Regular expression used to verify 64 bit (`int64` etc.) map keys.
+ * @type {RegExp}
+ * @const
+ */
+ util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
+ /**
+ * Converts a number or long to an 8 characters long hash string.
+ * @param {Long|number} value Value to convert
+ * @returns {string} Hash
+ */
+ util.longToHash = function longToHash(value) {
+ return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
+ };
+ /**
+ * Converts an 8 characters long hash string to a long or number.
+ * @param {string} hash Hash
+ * @param {boolean} [unsigned=false] Whether unsigned or not
+ * @returns {Long|number} Original value
+ */
+ util.longFromHash = function longFromHash(hash, unsigned) {
+ var bits = util.LongBits.fromHash(hash);
+ if (util.Long) return util.Long.fromBits(bits.lo, bits.hi, unsigned);
+ return bits.toNumber(Boolean(unsigned));
+ };
+ /**
+ * Merges the properties of the source object into the destination object.
+ * @memberof util
+ * @param {Object.} dst Destination object
+ * @param {...(Object.|boolean)} src Source objects, optionally followed by an `ifNotSet` flag
+ * @returns {Object.} Destination object
+ */
+ function merge(dst) {
+ var ifNotSet = typeof arguments[arguments.length - 1] === "boolean", limit = ifNotSet ? arguments.length - 1 : arguments.length;
+ ifNotSet = ifNotSet && arguments[arguments.length - 1];
+ for (var a = 1; a < limit; ++a) {
+ var src = arguments[a];
+ if (!src) continue;
+ for (var keys = Object.keys(src), i = 0; i < keys.length; ++i) if (!isUnsafeProperty(keys[i]) && (dst[keys[i]] === void 0 || !ifNotSet)) dst[keys[i]] = src[keys[i]];
+ }
+ return dst;
+ }
+ util.merge = merge;
+ /**
+ * Schema declaration nesting limit.
+ * @memberof util
+ * @type {number}
+ */
+ util.nestingLimit = 32;
+ /**
+ * Recursion limit.
+ * @memberof util
+ * @type {number}
+ */
+ util.recursionLimit = 100;
+ /**
+ * Makes a property safe for assignment as an own property.
+ * @memberof util
+ * @param {Object.} obj Object
+ * @param {string} key Property key
+ * @returns {undefined}
+ */
+ util.makeProp = function makeProp(obj, key) {
+ Object.defineProperty(obj, key, {
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ };
+ /**
+ * Converts the first character of a string to lower case.
+ * @param {string} str String to convert
+ * @returns {string} Converted string
+ */
+ util.lcFirst = function lcFirst(str$1) {
+ return str$1.charAt(0).toLowerCase() + str$1.substring(1);
+ };
+ /**
+ * Creates a custom error constructor.
+ * @memberof util
+ * @param {string} name Error name
+ * @returns {Constructor} Custom error constructor
+ */
+ function newError(name) {
+ function CustomError(message, properties) {
+ if (!(this instanceof CustomError)) return new CustomError(message, properties);
+ Object.defineProperty(this, "message", { get: function() {
+ return message;
+ } });
+ /* istanbul ignore next */
+ if (Error.captureStackTrace) Error.captureStackTrace(this, CustomError);
+ else Object.defineProperty(this, "stack", { value: (/* @__PURE__ */ new Error()).stack || "" });
+ if (properties) merge(this, properties);
+ }
+ CustomError.prototype = Object.create(Error.prototype, {
+ constructor: {
+ value: CustomError,
+ writable: true,
+ enumerable: false,
+ configurable: true
+ },
+ name: {
+ get: function get() {
+ return name;
+ },
+ set: void 0,
+ enumerable: false,
+ configurable: true
+ },
+ toString: {
+ value: function value() {
+ return this.name + ": " + this.message;
+ },
+ writable: true,
+ enumerable: false,
+ configurable: true
+ }
+ });
+ return CustomError;
+ }
+ util.newError = newError;
+ /**
+ * Constructs a new protocol error.
+ * @classdesc Error subclass indicating a protocol specifc error.
+ * @memberof util
+ * @extends Error
+ * @template T extends Message
+ * @constructor
+ * @param {string} message Error message
+ * @param {Object.} [properties] Additional properties
+ * @example
+ * try {
+ * MyMessage.decode(someBuffer); // throws if required fields are missing
+ * } catch (e) {
+ * if (e instanceof ProtocolError && e.instance)
+ * console.log("decoded so far: " + JSON.stringify(e.instance));
+ * }
+ */
+ util.ProtocolError = newError("ProtocolError");
+ /**
+ * So far decoded message instance.
+ * @name util.ProtocolError#instance
+ * @type {Message}
+ */
+ /**
+ * A OneOf getter as returned by {@link util.oneOfGetter}.
+ * @typedef OneOfGetter
+ * @type {function}
+ * @returns {string|undefined} Set field name, if any
+ */
+ /**
+ * Builds a getter for a oneof's present field name.
+ * @param {string[]} fieldNames Field names
+ * @returns {OneOfGetter} Unbound getter
+ */
+ util.oneOfGetter = function getOneOf(fieldNames) {
+ var fieldMap = {};
+ for (var i = 0; i < fieldNames.length; ++i) fieldMap[fieldNames[i]] = 1;
+ /**
+ * @returns {string|undefined} Set field name, if any
+ * @this Object
+ * @ignore
+ */
+ return function() {
+ for (var keys = Object.keys(this), i$1 = keys.length - 1; i$1 > -1; --i$1) if (fieldMap[keys[i$1]] === 1 && this[keys[i$1]] !== void 0 && this[keys[i$1]] !== null) return keys[i$1];
+ };
+ };
+ /**
+ * A OneOf setter as returned by {@link util.oneOfSetter}.
+ * @typedef OneOfSetter
+ * @type {function}
+ * @param {string|undefined} value Field name
+ * @returns {undefined}
+ */
+ /**
+ * Builds a setter for a oneof's present field name.
+ * @param {string[]} fieldNames Field names
+ * @returns {OneOfSetter} Unbound setter
+ */
+ util.oneOfSetter = function setOneOf(fieldNames) {
+ /**
+ * @param {string} name Field name
+ * @returns {undefined}
+ * @this Object
+ * @ignore
+ */
+ return function(name) {
+ for (var i = 0; i < fieldNames.length; ++i) if (fieldNames[i] !== name) delete this[fieldNames[i]];
+ };
+ };
+ /**
+ * Default conversion options used for {@link Message#toJSON} implementations.
+ *
+ * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
+ *
+ * - Longs become strings
+ * - Enums become string keys
+ * - Bytes become base64 encoded strings
+ * - (Sub-)Messages become plain objects
+ * - Maps become plain objects with all string keys
+ * - Repeated fields become arrays
+ * - NaN and Infinity for float and double fields become strings
+ *
+ * @type {IConversionOptions}
+ * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
+ */
+ util.toJSONOptions = {
+ longs: String,
+ enums: String,
+ bytes: String,
+ json: true
+ };
+ util._configure = function() {
+ var Buffer$1 = util.Buffer;
+ /* istanbul ignore if */
+ if (!Buffer$1) {
+ util._Buffer_from = util._Buffer_allocUnsafe = null;
+ return;
+ }
+ util._Buffer_from = Buffer$1.from !== Uint8Array.from && Buffer$1.from || function Buffer_from(value, encoding) {
+ return new Buffer$1(value, encoding);
+ };
+ util._Buffer_allocUnsafe = Buffer$1.allocUnsafe || function Buffer_allocUnsafe(size) {
+ return new Buffer$1(size);
+ };
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/writer.js
+var require_writer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = Writer;
+ var util = require_minimal$1();
+ var BufferWriter;
+ var LongBits = util.LongBits, base64 = util.base64, utf8 = util.utf8;
+ /**
+ * Constructs a new writer operation instance.
+ * @classdesc Scheduled writer operation.
+ * @constructor
+ * @param {function(*, Uint8Array, number)} fn Function to call
+ * @param {number} len Value byte length
+ * @param {*} val Value to write
+ * @ignore
+ */
+ function Op(fn, len, val) {
+ /**
+ * Function to call.
+ * @type {function(Uint8Array, number, *)}
+ */
+ this.fn = fn;
+ /**
+ * Value byte length.
+ * @type {number}
+ */
+ this.len = len;
+ /**
+ * Next operation.
+ * @type {Writer.Op|undefined}
+ */
+ this.next = void 0;
+ /**
+ * Value to write.
+ * @type {*}
+ */
+ this.val = val;
+ }
+ /* istanbul ignore next */
+ function noop() {}
+ /**
+ * Constructs a new writer state instance.
+ * @classdesc Copied writer state.
+ * @memberof Writer
+ * @constructor
+ * @param {Writer} writer Writer to copy state from
+ * @ignore
+ */
+ function State(writer) {
+ /**
+ * Current head.
+ * @type {Writer.Op}
+ */
+ this.head = writer.head;
+ /**
+ * Current tail.
+ * @type {Writer.Op}
+ */
+ this.tail = writer.tail;
+ /**
+ * Current buffer length.
+ * @type {number}
+ */
+ this.len = writer.len;
+ /**
+ * Next state.
+ * @type {State|null}
+ */
+ this.next = writer.states;
+ }
+ /**
+ * Constructs a new writer instance.
+ * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
+ * @constructor
+ */
+ function Writer() {
+ /**
+ * Current length.
+ * @type {number}
+ */
+ this.len = 0;
+ /**
+ * Operations head.
+ * @type {Object}
+ */
+ this.head = new Op(noop, 0, 0);
+ /**
+ * Operations tail
+ * @type {Object}
+ */
+ this.tail = this.head;
+ /**
+ * Linked forked states.
+ * @type {Object|null}
+ */
+ this.states = null;
+ }
+ var create = function create() {
+ return util.Buffer ? function create_buffer_setup() {
+ return (Writer.create = function create_buffer() {
+ return new BufferWriter();
+ })();
+ } : function create_array() {
+ return new Writer();
+ };
+ };
+ /**
+ * Creates a new writer.
+ * @function
+ * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
+ */
+ Writer.create = create();
+ /**
+ * Allocates a buffer of the specified size.
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+ Writer.alloc = function alloc(size) {
+ return new util.Array(size);
+ };
+ /* istanbul ignore else */
+ if (util.Array !== Array) Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
+ /**
+ * Pushes a new operation to the queue.
+ * @param {function(Uint8Array, number, *)} fn Function to call
+ * @param {number} len Value byte length
+ * @param {number} val Value to write
+ * @returns {Writer} `this`
+ * @private
+ */
+ Writer.prototype._push = function push(fn, len, val) {
+ this.tail = this.tail.next = new Op(fn, len, val);
+ this.len += len;
+ return this;
+ };
+ function writeByte(val, buf, pos) {
+ buf[pos] = val & 255;
+ }
+ function writeVarint32(val, buf, pos) {
+ while (val > 127) {
+ buf[pos++] = val & 127 | 128;
+ val >>>= 7;
+ }
+ buf[pos] = val;
+ }
+ /**
+ * Constructs a new varint writer operation instance.
+ * @classdesc Scheduled varint writer operation.
+ * @extends Op
+ * @constructor
+ * @param {number} len Value byte length
+ * @param {number} val Value to write
+ * @ignore
+ */
+ function VarintOp(len, val) {
+ this.len = len;
+ this.next = void 0;
+ this.val = val;
+ }
+ VarintOp.prototype = Object.create(Op.prototype);
+ VarintOp.prototype.fn = writeVarint32;
+ /**
+ * Writes an unsigned 32 bit value as a varint.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.uint32 = function write_uint32(value) {
+ this.len += (this.tail = this.tail.next = new VarintOp((value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, value)).len;
+ return this;
+ };
+ /**
+ * Writes a signed 32 bit value as a varint.
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.int32 = function write_int32(value) {
+ return (value |= 0) < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
+ };
+ /**
+ * Writes a 32 bit value as a varint, zig-zag encoded.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.sint32 = function write_sint32(value) {
+ return this.uint32((value << 1 ^ value >> 31) >>> 0);
+ };
+ function writeVarint64(val, buf, pos) {
+ var lo = val.lo, hi = val.hi;
+ while (hi) {
+ buf[pos++] = lo & 127 | 128;
+ lo = (lo >>> 7 | hi << 25) >>> 0;
+ hi >>>= 7;
+ }
+ while (lo > 127) {
+ buf[pos++] = lo & 127 | 128;
+ lo = lo >>> 7;
+ }
+ buf[pos++] = lo;
+ }
+ /**
+ * Writes an unsigned 64 bit value as a varint.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+ Writer.prototype.uint64 = function write_uint64(value) {
+ var bits = LongBits.from(value);
+ return this._push(writeVarint64, bits.length(), bits);
+ };
+ /**
+ * Writes a signed 64 bit value as a varint.
+ * @function
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+ Writer.prototype.int64 = Writer.prototype.uint64;
+ /**
+ * Writes a signed 64 bit value as a varint, zig-zag encoded.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+ Writer.prototype.sint64 = function write_sint64(value) {
+ var bits = LongBits.from(value).zzEncode();
+ return this._push(writeVarint64, bits.length(), bits);
+ };
+ /**
+ * Writes a boolish value as a varint.
+ * @param {boolean} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.bool = function write_bool(value) {
+ return this._push(writeByte, 1, value ? 1 : 0);
+ };
+ function writeFixed32(val, buf, pos) {
+ buf[pos] = val & 255;
+ buf[pos + 1] = val >>> 8 & 255;
+ buf[pos + 2] = val >>> 16 & 255;
+ buf[pos + 3] = val >>> 24;
+ }
+ /**
+ * Writes an unsigned 32 bit value as fixed 32 bits.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.fixed32 = function write_fixed32(value) {
+ return this._push(writeFixed32, 4, value >>> 0);
+ };
+ /**
+ * Writes a signed 32 bit value as fixed 32 bits.
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.sfixed32 = Writer.prototype.fixed32;
+ /**
+ * Writes an unsigned 64 bit value as fixed 64 bits.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+ Writer.prototype.fixed64 = function write_fixed64(value) {
+ var bits = LongBits.from(value);
+ return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+ };
+ /**
+ * Writes a signed 64 bit value as fixed 64 bits.
+ * @function
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+ Writer.prototype.sfixed64 = Writer.prototype.fixed64;
+ /**
+ * Writes a float (32 bit).
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.float = function write_float(value) {
+ return this._push(util.float.writeFloatLE, 4, value);
+ };
+ /**
+ * Writes a double (64 bit float).
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.double = function write_double(value) {
+ return this._push(util.float.writeDoubleLE, 8, value);
+ };
+ var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) {
+ buf.set(val, pos);
+ } : function writeBytes_for(val, buf, pos) {
+ for (var i = 0; i < val.length; ++i) buf[pos + i] = val[i];
+ };
+ /**
+ * Writes a sequence of bytes.
+ * @param {Uint8Array|string} value Buffer or base64 encoded string to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.bytes = function write_bytes(value) {
+ var len = value.length >>> 0;
+ if (!len) return this._push(writeByte, 1, 0);
+ if (util.isString(value)) {
+ var buf = Writer.alloc(len = base64.length(value));
+ base64.decode(value, buf, 0);
+ value = buf;
+ }
+ return this.uint32(len)._push(writeBytes, len, value);
+ };
+ /**
+ * Writes a string.
+ * @param {string} value Value to write
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.string = function write_string(value) {
+ var len = utf8.length(value);
+ return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0);
+ };
+ /**
+ * Forks this writer's state by pushing it to a stack.
+ * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.fork = function fork() {
+ this.states = new State(this);
+ this.head = this.tail = new Op(noop, 0, 0);
+ this.len = 0;
+ return this;
+ };
+ /**
+ * Resets this instance to the last state.
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.reset = function reset() {
+ if (this.states) {
+ this.head = this.states.head;
+ this.tail = this.states.tail;
+ this.len = this.states.len;
+ this.states = this.states.next;
+ } else {
+ this.head = this.tail = new Op(noop, 0, 0);
+ this.len = 0;
+ }
+ return this;
+ };
+ /**
+ * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
+ * @returns {Writer} `this`
+ */
+ Writer.prototype.ldelim = function ldelim() {
+ var head = this.head, tail = this.tail, len = this.len;
+ this.reset().uint32(len);
+ if (len) {
+ this.tail.next = head.next;
+ this.tail = tail;
+ this.len += len;
+ }
+ return this;
+ };
+ /**
+ * Finishes the write operation.
+ * @returns {Uint8Array} Finished buffer
+ */
+ Writer.prototype.finish = function finish() {
+ var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0;
+ while (head) {
+ head.fn(head.val, buf, pos);
+ pos += head.len;
+ head = head.next;
+ }
+ return buf;
+ };
+ Writer._configure = function(BufferWriter_) {
+ BufferWriter = BufferWriter_;
+ Writer.create = create();
+ BufferWriter._configure();
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/writer_buffer.js
+var require_writer_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = BufferWriter;
+ var Writer = require_writer();
+ (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
+ var util = require_minimal$1();
+ /**
+ * Constructs a new buffer writer instance.
+ * @classdesc Wire format writer using node buffers.
+ * @extends Writer
+ * @constructor
+ */
+ function BufferWriter() {
+ Writer.call(this);
+ }
+ BufferWriter._configure = function() {
+ /**
+ * Allocates a buffer of the specified size.
+ * @function
+ * @param {number} size Buffer size
+ * @returns {Buffer} Buffer
+ */
+ BufferWriter.alloc = util._Buffer_allocUnsafe;
+ BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
+ buf.set(val, pos);
+ } : function writeBytesBuffer_copy(val, buf, pos) {
+ if (val.copy) val.copy(buf, pos, 0, val.length);
+ else for (var i = 0; i < val.length;) buf[pos++] = val[i++];
+ };
+ };
+ /**
+ * @override
+ */
+ BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
+ if (util.isString(value)) value = util._Buffer_from(value, "base64");
+ var len = value.length >>> 0;
+ this.uint32(len);
+ if (len) this._push(BufferWriter.writeBytesBuffer, len, value);
+ return this;
+ };
+ function writeStringBuffer(val, buf, pos) {
+ if (val.length < 40) util.utf8.write(val, buf, pos);
+ else if (buf.utf8Write) buf.utf8Write(val, pos);
+ else buf.write(val, pos);
+ }
+ /**
+ * @override
+ */
+ BufferWriter.prototype.string = function write_string_buffer(value) {
+ var len = util.Buffer.byteLength(value);
+ this.uint32(len);
+ if (len) this._push(writeStringBuffer, len, value);
+ return this;
+ };
+ /**
+ * Finishes the write operation.
+ * @name BufferWriter#finish
+ * @function
+ * @returns {Buffer} Finished buffer
+ */
+ BufferWriter._configure();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/reader.js
+var require_reader = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = Reader;
+ var util = require_minimal$1();
+ var BufferReader;
+ var LongBits = util.LongBits, utf8 = util.utf8;
+ /* istanbul ignore next */
+ function indexOutOfRange(reader, writeLength) {
+ return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+ }
+ /**
+ * Constructs a new reader instance using the specified buffer.
+ * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
+ * @constructor
+ * @param {Uint8Array} buffer Buffer to read from
+ */
+ function Reader(buffer) {
+ /**
+ * Read buffer.
+ * @type {Uint8Array}
+ */
+ this.buf = buffer;
+ /**
+ * Read buffer position.
+ * @type {number}
+ */
+ this.pos = 0;
+ /**
+ * Read buffer length.
+ * @type {number}
+ */
+ this.len = buffer.length;
+ }
+ var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
+ if (buffer instanceof Uint8Array || Array.isArray(buffer)) return new Reader(buffer);
+ throw Error("illegal buffer");
+ } : function create_array(buffer) {
+ if (Array.isArray(buffer)) return new Reader(buffer);
+ throw Error("illegal buffer");
+ };
+ var create = function create() {
+ return util.Buffer ? function create_buffer_setup(buffer) {
+ return (Reader.create = function create_buffer(buffer$1) {
+ return util.Buffer.isBuffer(buffer$1) ? new BufferReader(buffer$1) : create_array(buffer$1);
+ })(buffer);
+ } : create_array;
+ };
+ /**
+ * Creates a new reader using the specified buffer.
+ * @function
+ * @param {Uint8Array|Buffer} buffer Buffer to read from
+ * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
+ * @throws {Error} If `buffer` is not a valid buffer
+ */
+ Reader.create = create();
+ Reader.prototype._slice = util.Array.prototype.subarray || util.Array.prototype.slice;
+ /**
+ * Reads a varint as an unsigned 32 bit value.
+ * @function
+ * @returns {number} Value read
+ */
+ Reader.prototype.uint32 = (function read_uint32_setup() {
+ var value = 4294967295;
+ return function read_uint32() {
+ value = (this.buf[this.pos] & 127) >>> 0;
+ if (this.buf[this.pos++] < 128) return value;
+ value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
+ if (this.buf[this.pos++] < 128) return value;
+ value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
+ if (this.buf[this.pos++] < 128) return value;
+ value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
+ if (this.buf[this.pos++] < 128) return value;
+ value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
+ if (this.buf[this.pos++] < 128) return value;
+ /* istanbul ignore if */
+ if ((this.pos += 5) > this.len) {
+ this.pos = this.len;
+ throw indexOutOfRange(this, 10);
+ }
+ return value;
+ };
+ })();
+ /**
+ * Reads a varint as a signed 32 bit value.
+ * @returns {number} Value read
+ */
+ Reader.prototype.int32 = function read_int32() {
+ return this.uint32() | 0;
+ };
+ /**
+ * Reads a zig-zag encoded varint as a signed 32 bit value.
+ * @returns {number} Value read
+ */
+ Reader.prototype.sint32 = function read_sint32() {
+ var value = this.uint32();
+ return value >>> 1 ^ -(value & 1) | 0;
+ };
+ function readLongVarint() {
+ var bits = new LongBits(0, 0);
+ var i = 0;
+ if (this.len - this.pos > 4) {
+ for (; i < 4; ++i) {
+ bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+ if (this.buf[this.pos++] < 128) return bits;
+ }
+ bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+ bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
+ if (this.buf[this.pos++] < 128) return bits;
+ i = 0;
+ } else {
+ for (; i < 3; ++i) {
+ /* istanbul ignore if */
+ if (this.pos >= this.len) throw indexOutOfRange(this);
+ bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+ if (this.buf[this.pos++] < 128) return bits;
+ }
+ bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+ return bits;
+ }
+ if (this.len - this.pos > 4) for (; i < 5; ++i) {
+ bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+ if (this.buf[this.pos++] < 128) return bits;
+ }
+ else for (; i < 5; ++i) {
+ /* istanbul ignore if */
+ if (this.pos >= this.len) throw indexOutOfRange(this);
+ bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+ if (this.buf[this.pos++] < 128) return bits;
+ }
+ /* istanbul ignore next */
+ throw Error("invalid varint encoding");
+ }
+ /**
+ * Reads a varint as a signed 64 bit value.
+ * @name Reader#int64
+ * @function
+ * @returns {Long} Value read
+ */
+ /**
+ * Reads a varint as an unsigned 64 bit value.
+ * @name Reader#uint64
+ * @function
+ * @returns {Long} Value read
+ */
+ /**
+ * Reads a zig-zag encoded varint as a signed 64 bit value.
+ * @name Reader#sint64
+ * @function
+ * @returns {Long} Value read
+ */
+ /**
+ * Reads a varint as a boolean.
+ * @returns {boolean} Value read
+ */
+ Reader.prototype.bool = function read_bool() {
+ return this.uint32() !== 0;
+ };
+ function readFixed32_end(buf, end) {
+ return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
+ }
+ /**
+ * Reads fixed 32 bits as an unsigned 32 bit integer.
+ * @returns {number} Value read
+ */
+ Reader.prototype.fixed32 = function read_fixed32() {
+ /* istanbul ignore if */
+ if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+ return readFixed32_end(this.buf, this.pos += 4);
+ };
+ /**
+ * Reads fixed 32 bits as a signed 32 bit integer.
+ * @returns {number} Value read
+ */
+ Reader.prototype.sfixed32 = function read_sfixed32() {
+ /* istanbul ignore if */
+ if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+ return readFixed32_end(this.buf, this.pos += 4) | 0;
+ };
+ function readFixed64() {
+ /* istanbul ignore if */
+ if (this.pos + 8 > this.len) throw indexOutOfRange(this, 8);
+ return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
+ }
+ /**
+ * Reads fixed 64 bits.
+ * @name Reader#fixed64
+ * @function
+ * @returns {Long} Value read
+ */
+ /**
+ * Reads zig-zag encoded fixed 64 bits.
+ * @name Reader#sfixed64
+ * @function
+ * @returns {Long} Value read
+ */
+ /**
+ * Reads a float (32 bit) as a number.
+ * @function
+ * @returns {number} Value read
+ */
+ Reader.prototype.float = function read_float() {
+ /* istanbul ignore if */
+ if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+ var value = util.float.readFloatLE(this.buf, this.pos);
+ this.pos += 4;
+ return value;
+ };
+ /**
+ * Reads a double (64 bit float) as a number.
+ * @function
+ * @returns {number} Value read
+ */
+ Reader.prototype.double = function read_double() {
+ /* istanbul ignore if */
+ if (this.pos + 8 > this.len) throw indexOutOfRange(this, 4);
+ var value = util.float.readDoubleLE(this.buf, this.pos);
+ this.pos += 8;
+ return value;
+ };
+ /**
+ * Reads a sequence of bytes preceeded by its length as a varint.
+ * @returns {Uint8Array} Value read
+ */
+ Reader.prototype.bytes = function read_bytes() {
+ var length = this.uint32(), start = this.pos, end = this.pos + length;
+ /* istanbul ignore if */
+ if (end > this.len) throw indexOutOfRange(this, length);
+ this.pos += length;
+ if (Array.isArray(this.buf)) return this.buf.slice(start, end);
+ if (start === end) {
+ var nativeBuffer = util.Buffer;
+ return nativeBuffer ? nativeBuffer.alloc(0) : new this.buf.constructor(0);
+ }
+ return this._slice.call(this.buf, start, end);
+ };
+ /**
+ * Reads a string preceeded by its byte length as a varint.
+ * @returns {string} Value read
+ */
+ Reader.prototype.string = function read_string() {
+ var bytes = this.bytes();
+ return utf8.read(bytes, 0, bytes.length);
+ };
+ /**
+ * Skips the specified number of bytes if specified, otherwise skips a varint.
+ * @param {number} [length] Length if known, otherwise a varint is assumed
+ * @returns {Reader} `this`
+ */
+ Reader.prototype.skip = function skip(length) {
+ if (typeof length === "number") {
+ /* istanbul ignore if */
+ if (this.pos + length > this.len) throw indexOutOfRange(this, length);
+ this.pos += length;
+ } else do
+ /* istanbul ignore if */
+ if (this.pos >= this.len) throw indexOutOfRange(this);
+ while (this.buf[this.pos++] & 128);
+ return this;
+ };
+ /**
+ * Recursion limit.
+ * @type {number}
+ */
+ Reader.recursionLimit = util.recursionLimit;
+ /**
+ * Skips the next element of the specified wire type.
+ * @param {number} wireType Wire type received
+ * @param {number} [depth] Depth of recursion to control nested calls; 0 if omitted
+ * @returns {Reader} `this`
+ */
+ Reader.prototype.skipType = function(wireType, depth) {
+ if (depth === void 0) depth = 0;
+ if (depth > Reader.recursionLimit) throw Error("maximum nesting depth exceeded");
+ switch (wireType) {
+ case 0:
+ this.skip();
+ break;
+ case 1:
+ this.skip(8);
+ break;
+ case 2:
+ this.skip(this.uint32());
+ break;
+ case 3:
+ while ((wireType = this.uint32() & 7) !== 4) this.skipType(wireType, depth + 1);
+ break;
+ case 5:
+ this.skip(4);
+ break;
+ default: throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+ }
+ return this;
+ };
+ Reader._configure = function(BufferReader_) {
+ BufferReader = BufferReader_;
+ Reader.create = create();
+ BufferReader._configure();
+ var fn = util.Long ? "toLong" : "toNumber";
+ util.merge(Reader.prototype, {
+ int64: function read_int64() {
+ return readLongVarint.call(this)[fn](false);
+ },
+ uint64: function read_uint64() {
+ return readLongVarint.call(this)[fn](true);
+ },
+ sint64: function read_sint64() {
+ return readLongVarint.call(this).zzDecode()[fn](false);
+ },
+ fixed64: function read_fixed64() {
+ return readFixed64.call(this)[fn](true);
+ },
+ sfixed64: function read_sfixed64() {
+ return readFixed64.call(this)[fn](false);
+ }
+ });
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/reader_buffer.js
+var require_reader_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = BufferReader;
+ var Reader = require_reader();
+ (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
+ var util = require_minimal$1();
+ /**
+ * Constructs a new buffer reader instance.
+ * @classdesc Wire format reader using node buffers.
+ * @extends Reader
+ * @constructor
+ * @param {Buffer} buffer Buffer to read from
+ */
+ function BufferReader(buffer) {
+ Reader.call(this, buffer);
+ /**
+ * Read buffer.
+ * @name BufferReader#buf
+ * @type {Buffer}
+ */
+ }
+ BufferReader._configure = function() {
+ /* istanbul ignore else */
+ if (util.Buffer) BufferReader.prototype._slice = util.Buffer.prototype.slice;
+ };
+ /**
+ * @override
+ */
+ BufferReader.prototype.string = function read_string_buffer() {
+ var len = this.uint32();
+ return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
+ };
+ /**
+ * Reads a sequence of bytes preceeded by its length as a varint.
+ * @name BufferReader#bytes
+ * @function
+ * @returns {Buffer} Value read
+ */
+ BufferReader._configure();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/rpc/service.js
+var require_service = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = Service;
+ var util = require_minimal$1();
+ (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
+ /**
+ * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
+ *
+ * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
+ * @typedef rpc.ServiceMethodCallback
+ * @template TRes extends Message
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {TRes} [response] Response message
+ * @returns {undefined}
+ */
+ /**
+ * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
+ * @typedef rpc.ServiceMethod
+ * @template TReq extends Message
+ * @template TRes extends Message
+ * @type {function}
+ * @param {TReq|Properties} request Request message or plain object
+ * @param {rpc.ServiceMethodCallback} [callback] Node-style callback called with the error, if any, and the response message
+ * @returns {Promise>} Promise if `callback` has been omitted, otherwise `undefined`
+ */
+ /**
+ * Constructs a new RPC service instance.
+ * @classdesc An RPC service as returned by {@link Service#create}.
+ * @exports rpc.Service
+ * @extends util.EventEmitter
+ * @constructor
+ * @param {RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ */
+ function Service(rpcImpl, requestDelimited, responseDelimited) {
+ if (typeof rpcImpl !== "function") throw TypeError("rpcImpl must be a function");
+ util.EventEmitter.call(this);
+ /**
+ * RPC implementation. Becomes `null` once the service is ended.
+ * @type {RPCImpl|null}
+ */
+ this.rpcImpl = rpcImpl;
+ /**
+ * Whether requests are length-delimited.
+ * @type {boolean}
+ */
+ this.requestDelimited = Boolean(requestDelimited);
+ /**
+ * Whether responses are length-delimited.
+ * @type {boolean}
+ */
+ this.responseDelimited = Boolean(responseDelimited);
+ }
+ /**
+ * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
+ * @param {Method|rpc.ServiceMethod} method Reflected or static method
+ * @param {Constructor} requestCtor Request constructor
+ * @param {Constructor} responseCtor Response constructor
+ * @param {TReq|Properties} request Request message or plain object
+ * @param {rpc.ServiceMethodCallback} callback Service callback
+ * @returns {undefined}
+ * @template TReq extends Message
+ * @template TRes extends Message
+ */
+ Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
+ if (!request) throw TypeError("request must be specified");
+ var self$1 = this;
+ if (!callback) return util.asPromise(rpcCall, self$1, method, requestCtor, responseCtor, request);
+ if (!self$1.rpcImpl) {
+ setTimeout(function() {
+ callback(Error("already ended"));
+ }, 0);
+ return;
+ }
+ try {
+ return self$1.rpcImpl(method, requestCtor[self$1.requestDelimited ? "encodeDelimited" : "encode"](request).finish(), function rpcCallback(err, response) {
+ if (err) {
+ self$1.emit("error", err, method);
+ return callback(err);
+ }
+ if (response === null) {
+ self$1.end(true);
+ return;
+ }
+ if (!(response instanceof responseCtor)) try {
+ response = responseCtor[self$1.responseDelimited ? "decodeDelimited" : "decode"](response);
+ } catch (err$1) {
+ self$1.emit("error", err$1, method);
+ return callback(err$1);
+ }
+ self$1.emit("data", response, method);
+ return callback(null, response);
+ });
+ } catch (err) {
+ self$1.emit("error", err, method);
+ setTimeout(function() {
+ callback(err);
+ }, 0);
+ return;
+ }
+ };
+ /**
+ * Ends this service and emits the `end` event.
+ * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.
+ * @returns {rpc.Service} `this`
+ */
+ Service.prototype.end = function end(endedByRPC) {
+ if (this.rpcImpl) {
+ if (!endedByRPC) this.rpcImpl(null, null, null);
+ this.rpcImpl = null;
+ this.emit("end").off();
+ }
+ return this;
+ };
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/rpc.js
+var require_rpc = /* @__PURE__ */ __commonJSMin(((exports) => {
+ /**
+ * Streaming RPC helpers.
+ * @namespace
+ */
+ var rpc = exports;
+ /**
+ * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
+ * @typedef RPCImpl
+ * @type {function}
+ * @param {Method|rpc.ServiceMethod,Message<{}>>} method Reflected or static method being called
+ * @param {Uint8Array} requestData Request data
+ * @param {RPCImplCallback} callback Callback function
+ * @returns {undefined}
+ * @example
+ * function rpcImpl(method, requestData, callback) {
+ * if (protobuf.util.lcFirst(method.name) !== "myMethod") // compatible with static code
+ * throw Error("no such method");
+ * asynchronouslyObtainAResponse(requestData, function(err, responseData) {
+ * callback(err, responseData);
+ * });
+ * }
+ */
+ /**
+ * Node-style callback as used by {@link RPCImpl}.
+ * @typedef RPCImplCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any, otherwise `null`
+ * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error
+ * @returns {undefined}
+ */
+ rpc.Service = require_service();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/roots.js
+var require_roots = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = Object.create(null);
+}));
+/**
+* Named roots.
+* This is where pbjs stores generated structures (the option `-r, --root` specifies a name).
+* Can also be used manually to make roots available across modules.
+* @name roots
+* @type {Object.}
+* @example
+* // pbjs -r myroot -o compiled.js ...
+*
+* // in another module:
+* require("./compiled.js");
+*
+* // in any subsequent module:
+* var root = protobuf.roots["myroot"];
+*/
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/src/index-minimal.js
+var require_index_minimal = /* @__PURE__ */ __commonJSMin(((exports) => {
+ var protobuf = exports;
+ /**
+ * Build type, one of `"full"`, `"light"` or `"minimal"`.
+ * @name build
+ * @type {string}
+ * @const
+ */
+ protobuf.build = "minimal";
+ protobuf.Writer = require_writer();
+ protobuf.BufferWriter = require_writer_buffer();
+ protobuf.Reader = require_reader();
+ protobuf.BufferReader = require_reader_buffer();
+ protobuf.util = require_minimal$1();
+ protobuf.rpc = require_rpc();
+ protobuf.roots = require_roots();
+ protobuf.configure = configure;
+ /* istanbul ignore next */
+ /**
+ * Reconfigures the library according to the environment.
+ * @returns {undefined}
+ */
+ function configure() {
+ protobuf.util._configure();
+ protobuf.Writer._configure(protobuf.BufferWriter);
+ protobuf.Reader._configure(protobuf.BufferReader);
+ }
+ configure();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/protobufjs@7.6.4/node_modules/protobufjs/minimal.js
+var require_minimal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ module.exports = require_index_minimal();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.205.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-transformer/build/src/generated/root.js
+var require_root = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+ Object.defineProperty(exports, "__esModule", { value: true });
+ var $protobuf = require_minimal();
+ var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+ var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
+ $root.opentelemetry = (function() {
+ /**
+ * Namespace opentelemetry.
+ * @exports opentelemetry
+ * @namespace
+ */
+ var opentelemetry = {};
+ opentelemetry.proto = (function() {
+ /**
+ * Namespace proto.
+ * @memberof opentelemetry
+ * @namespace
+ */
+ var proto = {};
+ proto.common = (function() {
+ /**
+ * Namespace common.
+ * @memberof opentelemetry.proto
+ * @namespace
+ */
+ var common = {};
+ common.v1 = (function() {
+ /**
+ * Namespace v1.
+ * @memberof opentelemetry.proto.common
+ * @namespace
+ */
+ var v1 = {};
+ v1.AnyValue = (function() {
+ /**
+ * Properties of an AnyValue.
+ * @memberof opentelemetry.proto.common.v1
+ * @interface IAnyValue
+ * @property {string|null} [stringValue] AnyValue stringValue
+ * @property {boolean|null} [boolValue] AnyValue boolValue
+ * @property {number|Long|null} [intValue] AnyValue intValue
+ * @property {number|null} [doubleValue] AnyValue doubleValue
+ * @property {opentelemetry.proto.common.v1.IArrayValue|null} [arrayValue] AnyValue arrayValue
+ * @property {opentelemetry.proto.common.v1.IKeyValueList|null} [kvlistValue] AnyValue kvlistValue
+ * @property {Uint8Array|null} [bytesValue] AnyValue bytesValue
+ */
+ /**
+ * Constructs a new AnyValue.
+ * @memberof opentelemetry.proto.common.v1
+ * @classdesc Represents an AnyValue.
+ * @implements IAnyValue
+ * @constructor
+ * @param {opentelemetry.proto.common.v1.IAnyValue=} [properties] Properties to set
+ */
+ function AnyValue(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * AnyValue stringValue.
+ * @member {string|null|undefined} stringValue
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ */
+ AnyValue.prototype.stringValue = null;
+ /**
+ * AnyValue boolValue.
+ * @member {boolean|null|undefined} boolValue
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ */
+ AnyValue.prototype.boolValue = null;
+ /**
+ * AnyValue intValue.
+ * @member {number|Long|null|undefined} intValue
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ */
+ AnyValue.prototype.intValue = null;
+ /**
+ * AnyValue doubleValue.
+ * @member {number|null|undefined} doubleValue
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ */
+ AnyValue.prototype.doubleValue = null;
+ /**
+ * AnyValue arrayValue.
+ * @member {opentelemetry.proto.common.v1.IArrayValue|null|undefined} arrayValue
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ */
+ AnyValue.prototype.arrayValue = null;
+ /**
+ * AnyValue kvlistValue.
+ * @member {opentelemetry.proto.common.v1.IKeyValueList|null|undefined} kvlistValue
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ */
+ AnyValue.prototype.kvlistValue = null;
+ /**
+ * AnyValue bytesValue.
+ * @member {Uint8Array|null|undefined} bytesValue
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ */
+ AnyValue.prototype.bytesValue = null;
+ var $oneOfFields;
+ /**
+ * AnyValue value.
+ * @member {"stringValue"|"boolValue"|"intValue"|"doubleValue"|"arrayValue"|"kvlistValue"|"bytesValue"|undefined} value
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ */
+ Object.defineProperty(AnyValue.prototype, "value", {
+ get: $util.oneOfGetter($oneOfFields = [
+ "stringValue",
+ "boolValue",
+ "intValue",
+ "doubleValue",
+ "arrayValue",
+ "kvlistValue",
+ "bytesValue"
+ ]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * Creates a new AnyValue instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IAnyValue=} [properties] Properties to set
+ * @returns {opentelemetry.proto.common.v1.AnyValue} AnyValue instance
+ */
+ AnyValue.create = function create(properties) {
+ return new AnyValue(properties);
+ };
+ /**
+ * Encodes the specified AnyValue message. Does not implicitly {@link opentelemetry.proto.common.v1.AnyValue.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IAnyValue} message AnyValue message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ AnyValue.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.stringValue != null && Object.hasOwnProperty.call(message, "stringValue")) writer.uint32(10).string(message.stringValue);
+ if (message.boolValue != null && Object.hasOwnProperty.call(message, "boolValue")) writer.uint32(16).bool(message.boolValue);
+ if (message.intValue != null && Object.hasOwnProperty.call(message, "intValue")) writer.uint32(24).int64(message.intValue);
+ if (message.doubleValue != null && Object.hasOwnProperty.call(message, "doubleValue")) writer.uint32(33).double(message.doubleValue);
+ if (message.arrayValue != null && Object.hasOwnProperty.call(message, "arrayValue")) $root.opentelemetry.proto.common.v1.ArrayValue.encode(message.arrayValue, writer.uint32(42).fork()).ldelim();
+ if (message.kvlistValue != null && Object.hasOwnProperty.call(message, "kvlistValue")) $root.opentelemetry.proto.common.v1.KeyValueList.encode(message.kvlistValue, writer.uint32(50).fork()).ldelim();
+ if (message.bytesValue != null && Object.hasOwnProperty.call(message, "bytesValue")) writer.uint32(58).bytes(message.bytesValue);
+ return writer;
+ };
+ /**
+ * Encodes the specified AnyValue message, length delimited. Does not implicitly {@link opentelemetry.proto.common.v1.AnyValue.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IAnyValue} message AnyValue message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ AnyValue.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an AnyValue message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.common.v1.AnyValue} AnyValue
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ AnyValue.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.common.v1.AnyValue();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.stringValue = reader.string();
+ break;
+ case 2:
+ message.boolValue = reader.bool();
+ break;
+ case 3:
+ message.intValue = reader.int64();
+ break;
+ case 4:
+ message.doubleValue = reader.double();
+ break;
+ case 5:
+ message.arrayValue = $root.opentelemetry.proto.common.v1.ArrayValue.decode(reader, reader.uint32());
+ break;
+ case 6:
+ message.kvlistValue = $root.opentelemetry.proto.common.v1.KeyValueList.decode(reader, reader.uint32());
+ break;
+ case 7:
+ message.bytesValue = reader.bytes();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an AnyValue message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.common.v1.AnyValue} AnyValue
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ AnyValue.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an AnyValue message.
+ * @function verify
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ AnyValue.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ var properties = {};
+ if (message.stringValue != null && message.hasOwnProperty("stringValue")) {
+ properties.value = 1;
+ if (!$util.isString(message.stringValue)) return "stringValue: string expected";
+ }
+ if (message.boolValue != null && message.hasOwnProperty("boolValue")) {
+ if (properties.value === 1) return "value: multiple values";
+ properties.value = 1;
+ if (typeof message.boolValue !== "boolean") return "boolValue: boolean expected";
+ }
+ if (message.intValue != null && message.hasOwnProperty("intValue")) {
+ if (properties.value === 1) return "value: multiple values";
+ properties.value = 1;
+ if (!$util.isInteger(message.intValue) && !(message.intValue && $util.isInteger(message.intValue.low) && $util.isInteger(message.intValue.high))) return "intValue: integer|Long expected";
+ }
+ if (message.doubleValue != null && message.hasOwnProperty("doubleValue")) {
+ if (properties.value === 1) return "value: multiple values";
+ properties.value = 1;
+ if (typeof message.doubleValue !== "number") return "doubleValue: number expected";
+ }
+ if (message.arrayValue != null && message.hasOwnProperty("arrayValue")) {
+ if (properties.value === 1) return "value: multiple values";
+ properties.value = 1;
+ var error = $root.opentelemetry.proto.common.v1.ArrayValue.verify(message.arrayValue);
+ if (error) return "arrayValue." + error;
+ }
+ if (message.kvlistValue != null && message.hasOwnProperty("kvlistValue")) {
+ if (properties.value === 1) return "value: multiple values";
+ properties.value = 1;
+ var error = $root.opentelemetry.proto.common.v1.KeyValueList.verify(message.kvlistValue);
+ if (error) return "kvlistValue." + error;
+ }
+ if (message.bytesValue != null && message.hasOwnProperty("bytesValue")) {
+ if (properties.value === 1) return "value: multiple values";
+ properties.value = 1;
+ if (!(message.bytesValue && typeof message.bytesValue.length === "number" || $util.isString(message.bytesValue))) return "bytesValue: buffer expected";
+ }
+ return null;
+ };
+ /**
+ * Creates an AnyValue message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.common.v1.AnyValue} AnyValue
+ */
+ AnyValue.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.common.v1.AnyValue) return object;
+ var message = new $root.opentelemetry.proto.common.v1.AnyValue();
+ if (object.stringValue != null) message.stringValue = String(object.stringValue);
+ if (object.boolValue != null) message.boolValue = Boolean(object.boolValue);
+ if (object.intValue != null) {
+ if ($util.Long) (message.intValue = $util.Long.fromValue(object.intValue)).unsigned = false;
+ else if (typeof object.intValue === "string") message.intValue = parseInt(object.intValue, 10);
+ else if (typeof object.intValue === "number") message.intValue = object.intValue;
+ else if (typeof object.intValue === "object") message.intValue = new $util.LongBits(object.intValue.low >>> 0, object.intValue.high >>> 0).toNumber();
+ }
+ if (object.doubleValue != null) message.doubleValue = Number(object.doubleValue);
+ if (object.arrayValue != null) {
+ if (typeof object.arrayValue !== "object") throw TypeError(".opentelemetry.proto.common.v1.AnyValue.arrayValue: object expected");
+ message.arrayValue = $root.opentelemetry.proto.common.v1.ArrayValue.fromObject(object.arrayValue);
+ }
+ if (object.kvlistValue != null) {
+ if (typeof object.kvlistValue !== "object") throw TypeError(".opentelemetry.proto.common.v1.AnyValue.kvlistValue: object expected");
+ message.kvlistValue = $root.opentelemetry.proto.common.v1.KeyValueList.fromObject(object.kvlistValue);
+ }
+ if (object.bytesValue != null) {
+ if (typeof object.bytesValue === "string") $util.base64.decode(object.bytesValue, message.bytesValue = $util.newBuffer($util.base64.length(object.bytesValue)), 0);
+ else if (object.bytesValue.length >= 0) message.bytesValue = object.bytesValue;
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an AnyValue message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.AnyValue} message AnyValue
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ AnyValue.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (message.stringValue != null && message.hasOwnProperty("stringValue")) {
+ object.stringValue = message.stringValue;
+ if (options.oneofs) object.value = "stringValue";
+ }
+ if (message.boolValue != null && message.hasOwnProperty("boolValue")) {
+ object.boolValue = message.boolValue;
+ if (options.oneofs) object.value = "boolValue";
+ }
+ if (message.intValue != null && message.hasOwnProperty("intValue")) {
+ if (typeof message.intValue === "number") object.intValue = options.longs === String ? String(message.intValue) : message.intValue;
+ else object.intValue = options.longs === String ? $util.Long.prototype.toString.call(message.intValue) : options.longs === Number ? new $util.LongBits(message.intValue.low >>> 0, message.intValue.high >>> 0).toNumber() : message.intValue;
+ if (options.oneofs) object.value = "intValue";
+ }
+ if (message.doubleValue != null && message.hasOwnProperty("doubleValue")) {
+ object.doubleValue = options.json && !isFinite(message.doubleValue) ? String(message.doubleValue) : message.doubleValue;
+ if (options.oneofs) object.value = "doubleValue";
+ }
+ if (message.arrayValue != null && message.hasOwnProperty("arrayValue")) {
+ object.arrayValue = $root.opentelemetry.proto.common.v1.ArrayValue.toObject(message.arrayValue, options);
+ if (options.oneofs) object.value = "arrayValue";
+ }
+ if (message.kvlistValue != null && message.hasOwnProperty("kvlistValue")) {
+ object.kvlistValue = $root.opentelemetry.proto.common.v1.KeyValueList.toObject(message.kvlistValue, options);
+ if (options.oneofs) object.value = "kvlistValue";
+ }
+ if (message.bytesValue != null && message.hasOwnProperty("bytesValue")) {
+ object.bytesValue = options.bytes === String ? $util.base64.encode(message.bytesValue, 0, message.bytesValue.length) : options.bytes === Array ? Array.prototype.slice.call(message.bytesValue) : message.bytesValue;
+ if (options.oneofs) object.value = "bytesValue";
+ }
+ return object;
+ };
+ /**
+ * Converts this AnyValue to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ AnyValue.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for AnyValue
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.common.v1.AnyValue
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ AnyValue.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.common.v1.AnyValue";
+ };
+ return AnyValue;
+ })();
+ v1.ArrayValue = (function() {
+ /**
+ * Properties of an ArrayValue.
+ * @memberof opentelemetry.proto.common.v1
+ * @interface IArrayValue
+ * @property {Array.|null} [values] ArrayValue values
+ */
+ /**
+ * Constructs a new ArrayValue.
+ * @memberof opentelemetry.proto.common.v1
+ * @classdesc Represents an ArrayValue.
+ * @implements IArrayValue
+ * @constructor
+ * @param {opentelemetry.proto.common.v1.IArrayValue=} [properties] Properties to set
+ */
+ function ArrayValue(properties) {
+ this.values = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ArrayValue values.
+ * @member {Array.} values
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @instance
+ */
+ ArrayValue.prototype.values = $util.emptyArray;
+ /**
+ * Creates a new ArrayValue instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IArrayValue=} [properties] Properties to set
+ * @returns {opentelemetry.proto.common.v1.ArrayValue} ArrayValue instance
+ */
+ ArrayValue.create = function create(properties) {
+ return new ArrayValue(properties);
+ };
+ /**
+ * Encodes the specified ArrayValue message. Does not implicitly {@link opentelemetry.proto.common.v1.ArrayValue.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IArrayValue} message ArrayValue message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ArrayValue.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.values != null && message.values.length) for (var i = 0; i < message.values.length; ++i) $root.opentelemetry.proto.common.v1.AnyValue.encode(message.values[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified ArrayValue message, length delimited. Does not implicitly {@link opentelemetry.proto.common.v1.ArrayValue.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IArrayValue} message ArrayValue message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ArrayValue.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ArrayValue message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.common.v1.ArrayValue} ArrayValue
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ArrayValue.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.common.v1.ArrayValue();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.values && message.values.length)) message.values = [];
+ message.values.push($root.opentelemetry.proto.common.v1.AnyValue.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ArrayValue message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.common.v1.ArrayValue} ArrayValue
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ArrayValue.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ArrayValue message.
+ * @function verify
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ArrayValue.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.values != null && message.hasOwnProperty("values")) {
+ if (!Array.isArray(message.values)) return "values: array expected";
+ for (var i = 0; i < message.values.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.AnyValue.verify(message.values[i]);
+ if (error) return "values." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates an ArrayValue message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.common.v1.ArrayValue} ArrayValue
+ */
+ ArrayValue.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.common.v1.ArrayValue) return object;
+ var message = new $root.opentelemetry.proto.common.v1.ArrayValue();
+ if (object.values) {
+ if (!Array.isArray(object.values)) throw TypeError(".opentelemetry.proto.common.v1.ArrayValue.values: array expected");
+ message.values = [];
+ for (var i = 0; i < object.values.length; ++i) {
+ if (typeof object.values[i] !== "object") throw TypeError(".opentelemetry.proto.common.v1.ArrayValue.values: object expected");
+ message.values[i] = $root.opentelemetry.proto.common.v1.AnyValue.fromObject(object.values[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an ArrayValue message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.ArrayValue} message ArrayValue
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ArrayValue.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.values = [];
+ if (message.values && message.values.length) {
+ object.values = [];
+ for (var j = 0; j < message.values.length; ++j) object.values[j] = $root.opentelemetry.proto.common.v1.AnyValue.toObject(message.values[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this ArrayValue to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ArrayValue.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ArrayValue
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.common.v1.ArrayValue
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ArrayValue.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.common.v1.ArrayValue";
+ };
+ return ArrayValue;
+ })();
+ v1.KeyValueList = (function() {
+ /**
+ * Properties of a KeyValueList.
+ * @memberof opentelemetry.proto.common.v1
+ * @interface IKeyValueList
+ * @property {Array.|null} [values] KeyValueList values
+ */
+ /**
+ * Constructs a new KeyValueList.
+ * @memberof opentelemetry.proto.common.v1
+ * @classdesc Represents a KeyValueList.
+ * @implements IKeyValueList
+ * @constructor
+ * @param {opentelemetry.proto.common.v1.IKeyValueList=} [properties] Properties to set
+ */
+ function KeyValueList(properties) {
+ this.values = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * KeyValueList values.
+ * @member {Array.} values
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @instance
+ */
+ KeyValueList.prototype.values = $util.emptyArray;
+ /**
+ * Creates a new KeyValueList instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {opentelemetry.proto.common.v1.IKeyValueList=} [properties] Properties to set
+ * @returns {opentelemetry.proto.common.v1.KeyValueList} KeyValueList instance
+ */
+ KeyValueList.create = function create(properties) {
+ return new KeyValueList(properties);
+ };
+ /**
+ * Encodes the specified KeyValueList message. Does not implicitly {@link opentelemetry.proto.common.v1.KeyValueList.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {opentelemetry.proto.common.v1.IKeyValueList} message KeyValueList message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ KeyValueList.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.values != null && message.values.length) for (var i = 0; i < message.values.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.values[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified KeyValueList message, length delimited. Does not implicitly {@link opentelemetry.proto.common.v1.KeyValueList.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {opentelemetry.proto.common.v1.IKeyValueList} message KeyValueList message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ KeyValueList.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a KeyValueList message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.common.v1.KeyValueList} KeyValueList
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ KeyValueList.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.common.v1.KeyValueList();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.values && message.values.length)) message.values = [];
+ message.values.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a KeyValueList message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.common.v1.KeyValueList} KeyValueList
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ KeyValueList.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a KeyValueList message.
+ * @function verify
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ KeyValueList.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.values != null && message.hasOwnProperty("values")) {
+ if (!Array.isArray(message.values)) return "values: array expected";
+ for (var i = 0; i < message.values.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.values[i]);
+ if (error) return "values." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates a KeyValueList message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.common.v1.KeyValueList} KeyValueList
+ */
+ KeyValueList.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.common.v1.KeyValueList) return object;
+ var message = new $root.opentelemetry.proto.common.v1.KeyValueList();
+ if (object.values) {
+ if (!Array.isArray(object.values)) throw TypeError(".opentelemetry.proto.common.v1.KeyValueList.values: array expected");
+ message.values = [];
+ for (var i = 0; i < object.values.length; ++i) {
+ if (typeof object.values[i] !== "object") throw TypeError(".opentelemetry.proto.common.v1.KeyValueList.values: object expected");
+ message.values[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.values[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a KeyValueList message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {opentelemetry.proto.common.v1.KeyValueList} message KeyValueList
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ KeyValueList.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.values = [];
+ if (message.values && message.values.length) {
+ object.values = [];
+ for (var j = 0; j < message.values.length; ++j) object.values[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.values[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this KeyValueList to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ KeyValueList.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for KeyValueList
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.common.v1.KeyValueList
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ KeyValueList.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.common.v1.KeyValueList";
+ };
+ return KeyValueList;
+ })();
+ v1.KeyValue = (function() {
+ /**
+ * Properties of a KeyValue.
+ * @memberof opentelemetry.proto.common.v1
+ * @interface IKeyValue
+ * @property {string|null} [key] KeyValue key
+ * @property {opentelemetry.proto.common.v1.IAnyValue|null} [value] KeyValue value
+ */
+ /**
+ * Constructs a new KeyValue.
+ * @memberof opentelemetry.proto.common.v1
+ * @classdesc Represents a KeyValue.
+ * @implements IKeyValue
+ * @constructor
+ * @param {opentelemetry.proto.common.v1.IKeyValue=} [properties] Properties to set
+ */
+ function KeyValue(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * KeyValue key.
+ * @member {string|null|undefined} key
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @instance
+ */
+ KeyValue.prototype.key = null;
+ /**
+ * KeyValue value.
+ * @member {opentelemetry.proto.common.v1.IAnyValue|null|undefined} value
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @instance
+ */
+ KeyValue.prototype.value = null;
+ /**
+ * Creates a new KeyValue instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IKeyValue=} [properties] Properties to set
+ * @returns {opentelemetry.proto.common.v1.KeyValue} KeyValue instance
+ */
+ KeyValue.create = function create(properties) {
+ return new KeyValue(properties);
+ };
+ /**
+ * Encodes the specified KeyValue message. Does not implicitly {@link opentelemetry.proto.common.v1.KeyValue.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IKeyValue} message KeyValue message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ KeyValue.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.key != null && Object.hasOwnProperty.call(message, "key")) writer.uint32(10).string(message.key);
+ if (message.value != null && Object.hasOwnProperty.call(message, "value")) $root.opentelemetry.proto.common.v1.AnyValue.encode(message.value, writer.uint32(18).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified KeyValue message, length delimited. Does not implicitly {@link opentelemetry.proto.common.v1.KeyValue.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.IKeyValue} message KeyValue message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ KeyValue.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a KeyValue message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.common.v1.KeyValue} KeyValue
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ KeyValue.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.common.v1.KeyValue();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.key = reader.string();
+ break;
+ case 2:
+ message.value = $root.opentelemetry.proto.common.v1.AnyValue.decode(reader, reader.uint32());
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a KeyValue message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.common.v1.KeyValue} KeyValue
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ KeyValue.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a KeyValue message.
+ * @function verify
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ KeyValue.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.key != null && message.hasOwnProperty("key")) {
+ if (!$util.isString(message.key)) return "key: string expected";
+ }
+ if (message.value != null && message.hasOwnProperty("value")) {
+ var error = $root.opentelemetry.proto.common.v1.AnyValue.verify(message.value);
+ if (error) return "value." + error;
+ }
+ return null;
+ };
+ /**
+ * Creates a KeyValue message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.common.v1.KeyValue} KeyValue
+ */
+ KeyValue.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.common.v1.KeyValue) return object;
+ var message = new $root.opentelemetry.proto.common.v1.KeyValue();
+ if (object.key != null) message.key = String(object.key);
+ if (object.value != null) {
+ if (typeof object.value !== "object") throw TypeError(".opentelemetry.proto.common.v1.KeyValue.value: object expected");
+ message.value = $root.opentelemetry.proto.common.v1.AnyValue.fromObject(object.value);
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a KeyValue message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {opentelemetry.proto.common.v1.KeyValue} message KeyValue
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ KeyValue.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.defaults) {
+ object.key = "";
+ object.value = null;
+ }
+ if (message.key != null && message.hasOwnProperty("key")) object.key = message.key;
+ if (message.value != null && message.hasOwnProperty("value")) object.value = $root.opentelemetry.proto.common.v1.AnyValue.toObject(message.value, options);
+ return object;
+ };
+ /**
+ * Converts this KeyValue to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ KeyValue.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for KeyValue
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.common.v1.KeyValue
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ KeyValue.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.common.v1.KeyValue";
+ };
+ return KeyValue;
+ })();
+ v1.InstrumentationScope = (function() {
+ /**
+ * Properties of an InstrumentationScope.
+ * @memberof opentelemetry.proto.common.v1
+ * @interface IInstrumentationScope
+ * @property {string|null} [name] InstrumentationScope name
+ * @property {string|null} [version] InstrumentationScope version
+ * @property {Array.|null} [attributes] InstrumentationScope attributes
+ * @property {number|null} [droppedAttributesCount] InstrumentationScope droppedAttributesCount
+ */
+ /**
+ * Constructs a new InstrumentationScope.
+ * @memberof opentelemetry.proto.common.v1
+ * @classdesc Represents an InstrumentationScope.
+ * @implements IInstrumentationScope
+ * @constructor
+ * @param {opentelemetry.proto.common.v1.IInstrumentationScope=} [properties] Properties to set
+ */
+ function InstrumentationScope(properties) {
+ this.attributes = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * InstrumentationScope name.
+ * @member {string|null|undefined} name
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @instance
+ */
+ InstrumentationScope.prototype.name = null;
+ /**
+ * InstrumentationScope version.
+ * @member {string|null|undefined} version
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @instance
+ */
+ InstrumentationScope.prototype.version = null;
+ /**
+ * InstrumentationScope attributes.
+ * @member {Array.} attributes
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @instance
+ */
+ InstrumentationScope.prototype.attributes = $util.emptyArray;
+ /**
+ * InstrumentationScope droppedAttributesCount.
+ * @member {number|null|undefined} droppedAttributesCount
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @instance
+ */
+ InstrumentationScope.prototype.droppedAttributesCount = null;
+ /**
+ * Creates a new InstrumentationScope instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {opentelemetry.proto.common.v1.IInstrumentationScope=} [properties] Properties to set
+ * @returns {opentelemetry.proto.common.v1.InstrumentationScope} InstrumentationScope instance
+ */
+ InstrumentationScope.create = function create(properties) {
+ return new InstrumentationScope(properties);
+ };
+ /**
+ * Encodes the specified InstrumentationScope message. Does not implicitly {@link opentelemetry.proto.common.v1.InstrumentationScope.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {opentelemetry.proto.common.v1.IInstrumentationScope} message InstrumentationScope message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ InstrumentationScope.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(10).string(message.name);
+ if (message.version != null && Object.hasOwnProperty.call(message, "version")) writer.uint32(18).string(message.version);
+ if (message.attributes != null && message.attributes.length) for (var i = 0; i < message.attributes.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.attributes[i], writer.uint32(26).fork()).ldelim();
+ if (message.droppedAttributesCount != null && Object.hasOwnProperty.call(message, "droppedAttributesCount")) writer.uint32(32).uint32(message.droppedAttributesCount);
+ return writer;
+ };
+ /**
+ * Encodes the specified InstrumentationScope message, length delimited. Does not implicitly {@link opentelemetry.proto.common.v1.InstrumentationScope.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {opentelemetry.proto.common.v1.IInstrumentationScope} message InstrumentationScope message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ InstrumentationScope.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an InstrumentationScope message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.common.v1.InstrumentationScope} InstrumentationScope
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ InstrumentationScope.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.common.v1.InstrumentationScope();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.name = reader.string();
+ break;
+ case 2:
+ message.version = reader.string();
+ break;
+ case 3:
+ if (!(message.attributes && message.attributes.length)) message.attributes = [];
+ message.attributes.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ case 4:
+ message.droppedAttributesCount = reader.uint32();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an InstrumentationScope message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.common.v1.InstrumentationScope} InstrumentationScope
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ InstrumentationScope.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an InstrumentationScope message.
+ * @function verify
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ InstrumentationScope.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.name != null && message.hasOwnProperty("name")) {
+ if (!$util.isString(message.name)) return "name: string expected";
+ }
+ if (message.version != null && message.hasOwnProperty("version")) {
+ if (!$util.isString(message.version)) return "version: string expected";
+ }
+ if (message.attributes != null && message.hasOwnProperty("attributes")) {
+ if (!Array.isArray(message.attributes)) return "attributes: array expected";
+ for (var i = 0; i < message.attributes.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.attributes[i]);
+ if (error) return "attributes." + error;
+ }
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) {
+ if (!$util.isInteger(message.droppedAttributesCount)) return "droppedAttributesCount: integer expected";
+ }
+ return null;
+ };
+ /**
+ * Creates an InstrumentationScope message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.common.v1.InstrumentationScope} InstrumentationScope
+ */
+ InstrumentationScope.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.common.v1.InstrumentationScope) return object;
+ var message = new $root.opentelemetry.proto.common.v1.InstrumentationScope();
+ if (object.name != null) message.name = String(object.name);
+ if (object.version != null) message.version = String(object.version);
+ if (object.attributes) {
+ if (!Array.isArray(object.attributes)) throw TypeError(".opentelemetry.proto.common.v1.InstrumentationScope.attributes: array expected");
+ message.attributes = [];
+ for (var i = 0; i < object.attributes.length; ++i) {
+ if (typeof object.attributes[i] !== "object") throw TypeError(".opentelemetry.proto.common.v1.InstrumentationScope.attributes: object expected");
+ message.attributes[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.attributes[i]);
+ }
+ }
+ if (object.droppedAttributesCount != null) message.droppedAttributesCount = object.droppedAttributesCount >>> 0;
+ return message;
+ };
+ /**
+ * Creates a plain object from an InstrumentationScope message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {opentelemetry.proto.common.v1.InstrumentationScope} message InstrumentationScope
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ InstrumentationScope.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.attributes = [];
+ if (options.defaults) {
+ object.name = "";
+ object.version = "";
+ object.droppedAttributesCount = 0;
+ }
+ if (message.name != null && message.hasOwnProperty("name")) object.name = message.name;
+ if (message.version != null && message.hasOwnProperty("version")) object.version = message.version;
+ if (message.attributes && message.attributes.length) {
+ object.attributes = [];
+ for (var j = 0; j < message.attributes.length; ++j) object.attributes[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.attributes[j], options);
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) object.droppedAttributesCount = message.droppedAttributesCount;
+ return object;
+ };
+ /**
+ * Converts this InstrumentationScope to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ InstrumentationScope.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for InstrumentationScope
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.common.v1.InstrumentationScope
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ InstrumentationScope.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.common.v1.InstrumentationScope";
+ };
+ return InstrumentationScope;
+ })();
+ v1.EntityRef = (function() {
+ /**
+ * Properties of an EntityRef.
+ * @memberof opentelemetry.proto.common.v1
+ * @interface IEntityRef
+ * @property {string|null} [schemaUrl] EntityRef schemaUrl
+ * @property {string|null} [type] EntityRef type
+ * @property {Array.|null} [idKeys] EntityRef idKeys
+ * @property {Array.|null} [descriptionKeys] EntityRef descriptionKeys
+ */
+ /**
+ * Constructs a new EntityRef.
+ * @memberof opentelemetry.proto.common.v1
+ * @classdesc Represents an EntityRef.
+ * @implements IEntityRef
+ * @constructor
+ * @param {opentelemetry.proto.common.v1.IEntityRef=} [properties] Properties to set
+ */
+ function EntityRef(properties) {
+ this.idKeys = [];
+ this.descriptionKeys = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * EntityRef schemaUrl.
+ * @member {string|null|undefined} schemaUrl
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @instance
+ */
+ EntityRef.prototype.schemaUrl = null;
+ /**
+ * EntityRef type.
+ * @member {string|null|undefined} type
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @instance
+ */
+ EntityRef.prototype.type = null;
+ /**
+ * EntityRef idKeys.
+ * @member {Array.} idKeys
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @instance
+ */
+ EntityRef.prototype.idKeys = $util.emptyArray;
+ /**
+ * EntityRef descriptionKeys.
+ * @member {Array.} descriptionKeys
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @instance
+ */
+ EntityRef.prototype.descriptionKeys = $util.emptyArray;
+ /**
+ * Creates a new EntityRef instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {opentelemetry.proto.common.v1.IEntityRef=} [properties] Properties to set
+ * @returns {opentelemetry.proto.common.v1.EntityRef} EntityRef instance
+ */
+ EntityRef.create = function create(properties) {
+ return new EntityRef(properties);
+ };
+ /**
+ * Encodes the specified EntityRef message. Does not implicitly {@link opentelemetry.proto.common.v1.EntityRef.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {opentelemetry.proto.common.v1.IEntityRef} message EntityRef message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ EntityRef.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.schemaUrl != null && Object.hasOwnProperty.call(message, "schemaUrl")) writer.uint32(10).string(message.schemaUrl);
+ if (message.type != null && Object.hasOwnProperty.call(message, "type")) writer.uint32(18).string(message.type);
+ if (message.idKeys != null && message.idKeys.length) for (var i = 0; i < message.idKeys.length; ++i) writer.uint32(26).string(message.idKeys[i]);
+ if (message.descriptionKeys != null && message.descriptionKeys.length) for (var i = 0; i < message.descriptionKeys.length; ++i) writer.uint32(34).string(message.descriptionKeys[i]);
+ return writer;
+ };
+ /**
+ * Encodes the specified EntityRef message, length delimited. Does not implicitly {@link opentelemetry.proto.common.v1.EntityRef.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {opentelemetry.proto.common.v1.IEntityRef} message EntityRef message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ EntityRef.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an EntityRef message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.common.v1.EntityRef} EntityRef
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ EntityRef.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.common.v1.EntityRef();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.schemaUrl = reader.string();
+ break;
+ case 2:
+ message.type = reader.string();
+ break;
+ case 3:
+ if (!(message.idKeys && message.idKeys.length)) message.idKeys = [];
+ message.idKeys.push(reader.string());
+ break;
+ case 4:
+ if (!(message.descriptionKeys && message.descriptionKeys.length)) message.descriptionKeys = [];
+ message.descriptionKeys.push(reader.string());
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an EntityRef message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.common.v1.EntityRef} EntityRef
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ EntityRef.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an EntityRef message.
+ * @function verify
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ EntityRef.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) {
+ if (!$util.isString(message.schemaUrl)) return "schemaUrl: string expected";
+ }
+ if (message.type != null && message.hasOwnProperty("type")) {
+ if (!$util.isString(message.type)) return "type: string expected";
+ }
+ if (message.idKeys != null && message.hasOwnProperty("idKeys")) {
+ if (!Array.isArray(message.idKeys)) return "idKeys: array expected";
+ for (var i = 0; i < message.idKeys.length; ++i) if (!$util.isString(message.idKeys[i])) return "idKeys: string[] expected";
+ }
+ if (message.descriptionKeys != null && message.hasOwnProperty("descriptionKeys")) {
+ if (!Array.isArray(message.descriptionKeys)) return "descriptionKeys: array expected";
+ for (var i = 0; i < message.descriptionKeys.length; ++i) if (!$util.isString(message.descriptionKeys[i])) return "descriptionKeys: string[] expected";
+ }
+ return null;
+ };
+ /**
+ * Creates an EntityRef message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.common.v1.EntityRef} EntityRef
+ */
+ EntityRef.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.common.v1.EntityRef) return object;
+ var message = new $root.opentelemetry.proto.common.v1.EntityRef();
+ if (object.schemaUrl != null) message.schemaUrl = String(object.schemaUrl);
+ if (object.type != null) message.type = String(object.type);
+ if (object.idKeys) {
+ if (!Array.isArray(object.idKeys)) throw TypeError(".opentelemetry.proto.common.v1.EntityRef.idKeys: array expected");
+ message.idKeys = [];
+ for (var i = 0; i < object.idKeys.length; ++i) message.idKeys[i] = String(object.idKeys[i]);
+ }
+ if (object.descriptionKeys) {
+ if (!Array.isArray(object.descriptionKeys)) throw TypeError(".opentelemetry.proto.common.v1.EntityRef.descriptionKeys: array expected");
+ message.descriptionKeys = [];
+ for (var i = 0; i < object.descriptionKeys.length; ++i) message.descriptionKeys[i] = String(object.descriptionKeys[i]);
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an EntityRef message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {opentelemetry.proto.common.v1.EntityRef} message EntityRef
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ EntityRef.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) {
+ object.idKeys = [];
+ object.descriptionKeys = [];
+ }
+ if (options.defaults) {
+ object.schemaUrl = "";
+ object.type = "";
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) object.schemaUrl = message.schemaUrl;
+ if (message.type != null && message.hasOwnProperty("type")) object.type = message.type;
+ if (message.idKeys && message.idKeys.length) {
+ object.idKeys = [];
+ for (var j = 0; j < message.idKeys.length; ++j) object.idKeys[j] = message.idKeys[j];
+ }
+ if (message.descriptionKeys && message.descriptionKeys.length) {
+ object.descriptionKeys = [];
+ for (var j = 0; j < message.descriptionKeys.length; ++j) object.descriptionKeys[j] = message.descriptionKeys[j];
+ }
+ return object;
+ };
+ /**
+ * Converts this EntityRef to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ EntityRef.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for EntityRef
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.common.v1.EntityRef
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ EntityRef.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.common.v1.EntityRef";
+ };
+ return EntityRef;
+ })();
+ return v1;
+ })();
+ return common;
+ })();
+ proto.resource = (function() {
+ /**
+ * Namespace resource.
+ * @memberof opentelemetry.proto
+ * @namespace
+ */
+ var resource = {};
+ resource.v1 = (function() {
+ /**
+ * Namespace v1.
+ * @memberof opentelemetry.proto.resource
+ * @namespace
+ */
+ var v1 = {};
+ v1.Resource = (function() {
+ /**
+ * Properties of a Resource.
+ * @memberof opentelemetry.proto.resource.v1
+ * @interface IResource
+ * @property {Array.|null} [attributes] Resource attributes
+ * @property {number|null} [droppedAttributesCount] Resource droppedAttributesCount
+ * @property {Array.|null} [entityRefs] Resource entityRefs
+ */
+ /**
+ * Constructs a new Resource.
+ * @memberof opentelemetry.proto.resource.v1
+ * @classdesc Represents a Resource.
+ * @implements IResource
+ * @constructor
+ * @param {opentelemetry.proto.resource.v1.IResource=} [properties] Properties to set
+ */
+ function Resource(properties) {
+ this.attributes = [];
+ this.entityRefs = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Resource attributes.
+ * @member {Array.} attributes
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @instance
+ */
+ Resource.prototype.attributes = $util.emptyArray;
+ /**
+ * Resource droppedAttributesCount.
+ * @member {number|null|undefined} droppedAttributesCount
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @instance
+ */
+ Resource.prototype.droppedAttributesCount = null;
+ /**
+ * Resource entityRefs.
+ * @member {Array.} entityRefs
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @instance
+ */
+ Resource.prototype.entityRefs = $util.emptyArray;
+ /**
+ * Creates a new Resource instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {opentelemetry.proto.resource.v1.IResource=} [properties] Properties to set
+ * @returns {opentelemetry.proto.resource.v1.Resource} Resource instance
+ */
+ Resource.create = function create(properties) {
+ return new Resource(properties);
+ };
+ /**
+ * Encodes the specified Resource message. Does not implicitly {@link opentelemetry.proto.resource.v1.Resource.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {opentelemetry.proto.resource.v1.IResource} message Resource message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Resource.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.attributes != null && message.attributes.length) for (var i = 0; i < message.attributes.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.attributes[i], writer.uint32(10).fork()).ldelim();
+ if (message.droppedAttributesCount != null && Object.hasOwnProperty.call(message, "droppedAttributesCount")) writer.uint32(16).uint32(message.droppedAttributesCount);
+ if (message.entityRefs != null && message.entityRefs.length) for (var i = 0; i < message.entityRefs.length; ++i) $root.opentelemetry.proto.common.v1.EntityRef.encode(message.entityRefs[i], writer.uint32(26).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified Resource message, length delimited. Does not implicitly {@link opentelemetry.proto.resource.v1.Resource.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {opentelemetry.proto.resource.v1.IResource} message Resource message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Resource.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Resource message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.resource.v1.Resource} Resource
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Resource.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.resource.v1.Resource();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.attributes && message.attributes.length)) message.attributes = [];
+ message.attributes.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ case 2:
+ message.droppedAttributesCount = reader.uint32();
+ break;
+ case 3:
+ if (!(message.entityRefs && message.entityRefs.length)) message.entityRefs = [];
+ message.entityRefs.push($root.opentelemetry.proto.common.v1.EntityRef.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Resource message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.resource.v1.Resource} Resource
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Resource.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Resource message.
+ * @function verify
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Resource.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.attributes != null && message.hasOwnProperty("attributes")) {
+ if (!Array.isArray(message.attributes)) return "attributes: array expected";
+ for (var i = 0; i < message.attributes.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.attributes[i]);
+ if (error) return "attributes." + error;
+ }
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) {
+ if (!$util.isInteger(message.droppedAttributesCount)) return "droppedAttributesCount: integer expected";
+ }
+ if (message.entityRefs != null && message.hasOwnProperty("entityRefs")) {
+ if (!Array.isArray(message.entityRefs)) return "entityRefs: array expected";
+ for (var i = 0; i < message.entityRefs.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.EntityRef.verify(message.entityRefs[i]);
+ if (error) return "entityRefs." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates a Resource message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.resource.v1.Resource} Resource
+ */
+ Resource.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.resource.v1.Resource) return object;
+ var message = new $root.opentelemetry.proto.resource.v1.Resource();
+ if (object.attributes) {
+ if (!Array.isArray(object.attributes)) throw TypeError(".opentelemetry.proto.resource.v1.Resource.attributes: array expected");
+ message.attributes = [];
+ for (var i = 0; i < object.attributes.length; ++i) {
+ if (typeof object.attributes[i] !== "object") throw TypeError(".opentelemetry.proto.resource.v1.Resource.attributes: object expected");
+ message.attributes[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.attributes[i]);
+ }
+ }
+ if (object.droppedAttributesCount != null) message.droppedAttributesCount = object.droppedAttributesCount >>> 0;
+ if (object.entityRefs) {
+ if (!Array.isArray(object.entityRefs)) throw TypeError(".opentelemetry.proto.resource.v1.Resource.entityRefs: array expected");
+ message.entityRefs = [];
+ for (var i = 0; i < object.entityRefs.length; ++i) {
+ if (typeof object.entityRefs[i] !== "object") throw TypeError(".opentelemetry.proto.resource.v1.Resource.entityRefs: object expected");
+ message.entityRefs[i] = $root.opentelemetry.proto.common.v1.EntityRef.fromObject(object.entityRefs[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a Resource message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {opentelemetry.proto.resource.v1.Resource} message Resource
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Resource.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) {
+ object.attributes = [];
+ object.entityRefs = [];
+ }
+ if (options.defaults) object.droppedAttributesCount = 0;
+ if (message.attributes && message.attributes.length) {
+ object.attributes = [];
+ for (var j = 0; j < message.attributes.length; ++j) object.attributes[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.attributes[j], options);
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) object.droppedAttributesCount = message.droppedAttributesCount;
+ if (message.entityRefs && message.entityRefs.length) {
+ object.entityRefs = [];
+ for (var j = 0; j < message.entityRefs.length; ++j) object.entityRefs[j] = $root.opentelemetry.proto.common.v1.EntityRef.toObject(message.entityRefs[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this Resource to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Resource.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Resource
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.resource.v1.Resource
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Resource.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.resource.v1.Resource";
+ };
+ return Resource;
+ })();
+ return v1;
+ })();
+ return resource;
+ })();
+ proto.trace = (function() {
+ /**
+ * Namespace trace.
+ * @memberof opentelemetry.proto
+ * @namespace
+ */
+ var trace$1 = {};
+ trace$1.v1 = (function() {
+ /**
+ * Namespace v1.
+ * @memberof opentelemetry.proto.trace
+ * @namespace
+ */
+ var v1 = {};
+ v1.TracesData = (function() {
+ /**
+ * Properties of a TracesData.
+ * @memberof opentelemetry.proto.trace.v1
+ * @interface ITracesData
+ * @property {Array.|null} [resourceSpans] TracesData resourceSpans
+ */
+ /**
+ * Constructs a new TracesData.
+ * @memberof opentelemetry.proto.trace.v1
+ * @classdesc Represents a TracesData.
+ * @implements ITracesData
+ * @constructor
+ * @param {opentelemetry.proto.trace.v1.ITracesData=} [properties] Properties to set
+ */
+ function TracesData(properties) {
+ this.resourceSpans = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * TracesData resourceSpans.
+ * @member {Array.} resourceSpans
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @instance
+ */
+ TracesData.prototype.resourceSpans = $util.emptyArray;
+ /**
+ * Creates a new TracesData instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {opentelemetry.proto.trace.v1.ITracesData=} [properties] Properties to set
+ * @returns {opentelemetry.proto.trace.v1.TracesData} TracesData instance
+ */
+ TracesData.create = function create(properties) {
+ return new TracesData(properties);
+ };
+ /**
+ * Encodes the specified TracesData message. Does not implicitly {@link opentelemetry.proto.trace.v1.TracesData.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {opentelemetry.proto.trace.v1.ITracesData} message TracesData message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ TracesData.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.resourceSpans != null && message.resourceSpans.length) for (var i = 0; i < message.resourceSpans.length; ++i) $root.opentelemetry.proto.trace.v1.ResourceSpans.encode(message.resourceSpans[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified TracesData message, length delimited. Does not implicitly {@link opentelemetry.proto.trace.v1.TracesData.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {opentelemetry.proto.trace.v1.ITracesData} message TracesData message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ TracesData.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a TracesData message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.trace.v1.TracesData} TracesData
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ TracesData.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.TracesData();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.resourceSpans && message.resourceSpans.length)) message.resourceSpans = [];
+ message.resourceSpans.push($root.opentelemetry.proto.trace.v1.ResourceSpans.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a TracesData message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.trace.v1.TracesData} TracesData
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ TracesData.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a TracesData message.
+ * @function verify
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ TracesData.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.resourceSpans != null && message.hasOwnProperty("resourceSpans")) {
+ if (!Array.isArray(message.resourceSpans)) return "resourceSpans: array expected";
+ for (var i = 0; i < message.resourceSpans.length; ++i) {
+ var error = $root.opentelemetry.proto.trace.v1.ResourceSpans.verify(message.resourceSpans[i]);
+ if (error) return "resourceSpans." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates a TracesData message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.trace.v1.TracesData} TracesData
+ */
+ TracesData.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.trace.v1.TracesData) return object;
+ var message = new $root.opentelemetry.proto.trace.v1.TracesData();
+ if (object.resourceSpans) {
+ if (!Array.isArray(object.resourceSpans)) throw TypeError(".opentelemetry.proto.trace.v1.TracesData.resourceSpans: array expected");
+ message.resourceSpans = [];
+ for (var i = 0; i < object.resourceSpans.length; ++i) {
+ if (typeof object.resourceSpans[i] !== "object") throw TypeError(".opentelemetry.proto.trace.v1.TracesData.resourceSpans: object expected");
+ message.resourceSpans[i] = $root.opentelemetry.proto.trace.v1.ResourceSpans.fromObject(object.resourceSpans[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a TracesData message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {opentelemetry.proto.trace.v1.TracesData} message TracesData
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ TracesData.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.resourceSpans = [];
+ if (message.resourceSpans && message.resourceSpans.length) {
+ object.resourceSpans = [];
+ for (var j = 0; j < message.resourceSpans.length; ++j) object.resourceSpans[j] = $root.opentelemetry.proto.trace.v1.ResourceSpans.toObject(message.resourceSpans[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this TracesData to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ TracesData.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for TracesData
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.trace.v1.TracesData
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ TracesData.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.trace.v1.TracesData";
+ };
+ return TracesData;
+ })();
+ v1.ResourceSpans = (function() {
+ /**
+ * Properties of a ResourceSpans.
+ * @memberof opentelemetry.proto.trace.v1
+ * @interface IResourceSpans
+ * @property {opentelemetry.proto.resource.v1.IResource|null} [resource] ResourceSpans resource
+ * @property {Array.|null} [scopeSpans] ResourceSpans scopeSpans
+ * @property {string|null} [schemaUrl] ResourceSpans schemaUrl
+ */
+ /**
+ * Constructs a new ResourceSpans.
+ * @memberof opentelemetry.proto.trace.v1
+ * @classdesc Represents a ResourceSpans.
+ * @implements IResourceSpans
+ * @constructor
+ * @param {opentelemetry.proto.trace.v1.IResourceSpans=} [properties] Properties to set
+ */
+ function ResourceSpans(properties) {
+ this.scopeSpans = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ResourceSpans resource.
+ * @member {opentelemetry.proto.resource.v1.IResource|null|undefined} resource
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @instance
+ */
+ ResourceSpans.prototype.resource = null;
+ /**
+ * ResourceSpans scopeSpans.
+ * @member {Array.} scopeSpans
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @instance
+ */
+ ResourceSpans.prototype.scopeSpans = $util.emptyArray;
+ /**
+ * ResourceSpans schemaUrl.
+ * @member {string|null|undefined} schemaUrl
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @instance
+ */
+ ResourceSpans.prototype.schemaUrl = null;
+ /**
+ * Creates a new ResourceSpans instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IResourceSpans=} [properties] Properties to set
+ * @returns {opentelemetry.proto.trace.v1.ResourceSpans} ResourceSpans instance
+ */
+ ResourceSpans.create = function create(properties) {
+ return new ResourceSpans(properties);
+ };
+ /**
+ * Encodes the specified ResourceSpans message. Does not implicitly {@link opentelemetry.proto.trace.v1.ResourceSpans.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IResourceSpans} message ResourceSpans message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ResourceSpans.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.resource != null && Object.hasOwnProperty.call(message, "resource")) $root.opentelemetry.proto.resource.v1.Resource.encode(message.resource, writer.uint32(10).fork()).ldelim();
+ if (message.scopeSpans != null && message.scopeSpans.length) for (var i = 0; i < message.scopeSpans.length; ++i) $root.opentelemetry.proto.trace.v1.ScopeSpans.encode(message.scopeSpans[i], writer.uint32(18).fork()).ldelim();
+ if (message.schemaUrl != null && Object.hasOwnProperty.call(message, "schemaUrl")) writer.uint32(26).string(message.schemaUrl);
+ return writer;
+ };
+ /**
+ * Encodes the specified ResourceSpans message, length delimited. Does not implicitly {@link opentelemetry.proto.trace.v1.ResourceSpans.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IResourceSpans} message ResourceSpans message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ResourceSpans.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a ResourceSpans message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.trace.v1.ResourceSpans} ResourceSpans
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ResourceSpans.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.ResourceSpans();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.resource = $root.opentelemetry.proto.resource.v1.Resource.decode(reader, reader.uint32());
+ break;
+ case 2:
+ if (!(message.scopeSpans && message.scopeSpans.length)) message.scopeSpans = [];
+ message.scopeSpans.push($root.opentelemetry.proto.trace.v1.ScopeSpans.decode(reader, reader.uint32()));
+ break;
+ case 3:
+ message.schemaUrl = reader.string();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a ResourceSpans message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.trace.v1.ResourceSpans} ResourceSpans
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ResourceSpans.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a ResourceSpans message.
+ * @function verify
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ResourceSpans.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.resource != null && message.hasOwnProperty("resource")) {
+ var error = $root.opentelemetry.proto.resource.v1.Resource.verify(message.resource);
+ if (error) return "resource." + error;
+ }
+ if (message.scopeSpans != null && message.hasOwnProperty("scopeSpans")) {
+ if (!Array.isArray(message.scopeSpans)) return "scopeSpans: array expected";
+ for (var i = 0; i < message.scopeSpans.length; ++i) {
+ var error = $root.opentelemetry.proto.trace.v1.ScopeSpans.verify(message.scopeSpans[i]);
+ if (error) return "scopeSpans." + error;
+ }
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) {
+ if (!$util.isString(message.schemaUrl)) return "schemaUrl: string expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a ResourceSpans message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.trace.v1.ResourceSpans} ResourceSpans
+ */
+ ResourceSpans.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.trace.v1.ResourceSpans) return object;
+ var message = new $root.opentelemetry.proto.trace.v1.ResourceSpans();
+ if (object.resource != null) {
+ if (typeof object.resource !== "object") throw TypeError(".opentelemetry.proto.trace.v1.ResourceSpans.resource: object expected");
+ message.resource = $root.opentelemetry.proto.resource.v1.Resource.fromObject(object.resource);
+ }
+ if (object.scopeSpans) {
+ if (!Array.isArray(object.scopeSpans)) throw TypeError(".opentelemetry.proto.trace.v1.ResourceSpans.scopeSpans: array expected");
+ message.scopeSpans = [];
+ for (var i = 0; i < object.scopeSpans.length; ++i) {
+ if (typeof object.scopeSpans[i] !== "object") throw TypeError(".opentelemetry.proto.trace.v1.ResourceSpans.scopeSpans: object expected");
+ message.scopeSpans[i] = $root.opentelemetry.proto.trace.v1.ScopeSpans.fromObject(object.scopeSpans[i]);
+ }
+ }
+ if (object.schemaUrl != null) message.schemaUrl = String(object.schemaUrl);
+ return message;
+ };
+ /**
+ * Creates a plain object from a ResourceSpans message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {opentelemetry.proto.trace.v1.ResourceSpans} message ResourceSpans
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ResourceSpans.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.scopeSpans = [];
+ if (options.defaults) {
+ object.resource = null;
+ object.schemaUrl = "";
+ }
+ if (message.resource != null && message.hasOwnProperty("resource")) object.resource = $root.opentelemetry.proto.resource.v1.Resource.toObject(message.resource, options);
+ if (message.scopeSpans && message.scopeSpans.length) {
+ object.scopeSpans = [];
+ for (var j = 0; j < message.scopeSpans.length; ++j) object.scopeSpans[j] = $root.opentelemetry.proto.trace.v1.ScopeSpans.toObject(message.scopeSpans[j], options);
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) object.schemaUrl = message.schemaUrl;
+ return object;
+ };
+ /**
+ * Converts this ResourceSpans to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ResourceSpans.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ResourceSpans
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.trace.v1.ResourceSpans
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ResourceSpans.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.trace.v1.ResourceSpans";
+ };
+ return ResourceSpans;
+ })();
+ v1.ScopeSpans = (function() {
+ /**
+ * Properties of a ScopeSpans.
+ * @memberof opentelemetry.proto.trace.v1
+ * @interface IScopeSpans
+ * @property {opentelemetry.proto.common.v1.IInstrumentationScope|null} [scope] ScopeSpans scope
+ * @property {Array.|null} [spans] ScopeSpans spans
+ * @property {string|null} [schemaUrl] ScopeSpans schemaUrl
+ */
+ /**
+ * Constructs a new ScopeSpans.
+ * @memberof opentelemetry.proto.trace.v1
+ * @classdesc Represents a ScopeSpans.
+ * @implements IScopeSpans
+ * @constructor
+ * @param {opentelemetry.proto.trace.v1.IScopeSpans=} [properties] Properties to set
+ */
+ function ScopeSpans(properties) {
+ this.spans = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ScopeSpans scope.
+ * @member {opentelemetry.proto.common.v1.IInstrumentationScope|null|undefined} scope
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @instance
+ */
+ ScopeSpans.prototype.scope = null;
+ /**
+ * ScopeSpans spans.
+ * @member {Array.} spans
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @instance
+ */
+ ScopeSpans.prototype.spans = $util.emptyArray;
+ /**
+ * ScopeSpans schemaUrl.
+ * @member {string|null|undefined} schemaUrl
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @instance
+ */
+ ScopeSpans.prototype.schemaUrl = null;
+ /**
+ * Creates a new ScopeSpans instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IScopeSpans=} [properties] Properties to set
+ * @returns {opentelemetry.proto.trace.v1.ScopeSpans} ScopeSpans instance
+ */
+ ScopeSpans.create = function create(properties) {
+ return new ScopeSpans(properties);
+ };
+ /**
+ * Encodes the specified ScopeSpans message. Does not implicitly {@link opentelemetry.proto.trace.v1.ScopeSpans.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IScopeSpans} message ScopeSpans message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ScopeSpans.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.scope != null && Object.hasOwnProperty.call(message, "scope")) $root.opentelemetry.proto.common.v1.InstrumentationScope.encode(message.scope, writer.uint32(10).fork()).ldelim();
+ if (message.spans != null && message.spans.length) for (var i = 0; i < message.spans.length; ++i) $root.opentelemetry.proto.trace.v1.Span.encode(message.spans[i], writer.uint32(18).fork()).ldelim();
+ if (message.schemaUrl != null && Object.hasOwnProperty.call(message, "schemaUrl")) writer.uint32(26).string(message.schemaUrl);
+ return writer;
+ };
+ /**
+ * Encodes the specified ScopeSpans message, length delimited. Does not implicitly {@link opentelemetry.proto.trace.v1.ScopeSpans.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IScopeSpans} message ScopeSpans message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ScopeSpans.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a ScopeSpans message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.trace.v1.ScopeSpans} ScopeSpans
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ScopeSpans.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.ScopeSpans();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.scope = $root.opentelemetry.proto.common.v1.InstrumentationScope.decode(reader, reader.uint32());
+ break;
+ case 2:
+ if (!(message.spans && message.spans.length)) message.spans = [];
+ message.spans.push($root.opentelemetry.proto.trace.v1.Span.decode(reader, reader.uint32()));
+ break;
+ case 3:
+ message.schemaUrl = reader.string();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a ScopeSpans message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.trace.v1.ScopeSpans} ScopeSpans
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ScopeSpans.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a ScopeSpans message.
+ * @function verify
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ScopeSpans.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.scope != null && message.hasOwnProperty("scope")) {
+ var error = $root.opentelemetry.proto.common.v1.InstrumentationScope.verify(message.scope);
+ if (error) return "scope." + error;
+ }
+ if (message.spans != null && message.hasOwnProperty("spans")) {
+ if (!Array.isArray(message.spans)) return "spans: array expected";
+ for (var i = 0; i < message.spans.length; ++i) {
+ var error = $root.opentelemetry.proto.trace.v1.Span.verify(message.spans[i]);
+ if (error) return "spans." + error;
+ }
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) {
+ if (!$util.isString(message.schemaUrl)) return "schemaUrl: string expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a ScopeSpans message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.trace.v1.ScopeSpans} ScopeSpans
+ */
+ ScopeSpans.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.trace.v1.ScopeSpans) return object;
+ var message = new $root.opentelemetry.proto.trace.v1.ScopeSpans();
+ if (object.scope != null) {
+ if (typeof object.scope !== "object") throw TypeError(".opentelemetry.proto.trace.v1.ScopeSpans.scope: object expected");
+ message.scope = $root.opentelemetry.proto.common.v1.InstrumentationScope.fromObject(object.scope);
+ }
+ if (object.spans) {
+ if (!Array.isArray(object.spans)) throw TypeError(".opentelemetry.proto.trace.v1.ScopeSpans.spans: array expected");
+ message.spans = [];
+ for (var i = 0; i < object.spans.length; ++i) {
+ if (typeof object.spans[i] !== "object") throw TypeError(".opentelemetry.proto.trace.v1.ScopeSpans.spans: object expected");
+ message.spans[i] = $root.opentelemetry.proto.trace.v1.Span.fromObject(object.spans[i]);
+ }
+ }
+ if (object.schemaUrl != null) message.schemaUrl = String(object.schemaUrl);
+ return message;
+ };
+ /**
+ * Creates a plain object from a ScopeSpans message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {opentelemetry.proto.trace.v1.ScopeSpans} message ScopeSpans
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ScopeSpans.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.spans = [];
+ if (options.defaults) {
+ object.scope = null;
+ object.schemaUrl = "";
+ }
+ if (message.scope != null && message.hasOwnProperty("scope")) object.scope = $root.opentelemetry.proto.common.v1.InstrumentationScope.toObject(message.scope, options);
+ if (message.spans && message.spans.length) {
+ object.spans = [];
+ for (var j = 0; j < message.spans.length; ++j) object.spans[j] = $root.opentelemetry.proto.trace.v1.Span.toObject(message.spans[j], options);
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) object.schemaUrl = message.schemaUrl;
+ return object;
+ };
+ /**
+ * Converts this ScopeSpans to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ScopeSpans.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ScopeSpans
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.trace.v1.ScopeSpans
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ScopeSpans.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.trace.v1.ScopeSpans";
+ };
+ return ScopeSpans;
+ })();
+ v1.Span = (function() {
+ /**
+ * Properties of a Span.
+ * @memberof opentelemetry.proto.trace.v1
+ * @interface ISpan
+ * @property {Uint8Array|null} [traceId] Span traceId
+ * @property {Uint8Array|null} [spanId] Span spanId
+ * @property {string|null} [traceState] Span traceState
+ * @property {Uint8Array|null} [parentSpanId] Span parentSpanId
+ * @property {number|null} [flags] Span flags
+ * @property {string|null} [name] Span name
+ * @property {opentelemetry.proto.trace.v1.Span.SpanKind|null} [kind] Span kind
+ * @property {number|Long|null} [startTimeUnixNano] Span startTimeUnixNano
+ * @property {number|Long|null} [endTimeUnixNano] Span endTimeUnixNano
+ * @property {Array.|null} [attributes] Span attributes
+ * @property {number|null} [droppedAttributesCount] Span droppedAttributesCount
+ * @property {Array.|null} [events] Span events
+ * @property {number|null} [droppedEventsCount] Span droppedEventsCount
+ * @property {Array.|null} [links] Span links
+ * @property {number|null} [droppedLinksCount] Span droppedLinksCount
+ * @property {opentelemetry.proto.trace.v1.IStatus|null} [status] Span status
+ */
+ /**
+ * Constructs a new Span.
+ * @memberof opentelemetry.proto.trace.v1
+ * @classdesc Represents a Span.
+ * @implements ISpan
+ * @constructor
+ * @param {opentelemetry.proto.trace.v1.ISpan=} [properties] Properties to set
+ */
+ function Span(properties) {
+ this.attributes = [];
+ this.events = [];
+ this.links = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Span traceId.
+ * @member {Uint8Array|null|undefined} traceId
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.traceId = null;
+ /**
+ * Span spanId.
+ * @member {Uint8Array|null|undefined} spanId
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.spanId = null;
+ /**
+ * Span traceState.
+ * @member {string|null|undefined} traceState
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.traceState = null;
+ /**
+ * Span parentSpanId.
+ * @member {Uint8Array|null|undefined} parentSpanId
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.parentSpanId = null;
+ /**
+ * Span flags.
+ * @member {number|null|undefined} flags
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.flags = null;
+ /**
+ * Span name.
+ * @member {string|null|undefined} name
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.name = null;
+ /**
+ * Span kind.
+ * @member {opentelemetry.proto.trace.v1.Span.SpanKind|null|undefined} kind
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.kind = null;
+ /**
+ * Span startTimeUnixNano.
+ * @member {number|Long|null|undefined} startTimeUnixNano
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.startTimeUnixNano = null;
+ /**
+ * Span endTimeUnixNano.
+ * @member {number|Long|null|undefined} endTimeUnixNano
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.endTimeUnixNano = null;
+ /**
+ * Span attributes.
+ * @member {Array.} attributes
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.attributes = $util.emptyArray;
+ /**
+ * Span droppedAttributesCount.
+ * @member {number|null|undefined} droppedAttributesCount
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.droppedAttributesCount = null;
+ /**
+ * Span events.
+ * @member {Array.} events
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.events = $util.emptyArray;
+ /**
+ * Span droppedEventsCount.
+ * @member {number|null|undefined} droppedEventsCount
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.droppedEventsCount = null;
+ /**
+ * Span links.
+ * @member {Array.} links
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.links = $util.emptyArray;
+ /**
+ * Span droppedLinksCount.
+ * @member {number|null|undefined} droppedLinksCount
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.droppedLinksCount = null;
+ /**
+ * Span status.
+ * @member {opentelemetry.proto.trace.v1.IStatus|null|undefined} status
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ */
+ Span.prototype.status = null;
+ /**
+ * Creates a new Span instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {opentelemetry.proto.trace.v1.ISpan=} [properties] Properties to set
+ * @returns {opentelemetry.proto.trace.v1.Span} Span instance
+ */
+ Span.create = function create(properties) {
+ return new Span(properties);
+ };
+ /**
+ * Encodes the specified Span message. Does not implicitly {@link opentelemetry.proto.trace.v1.Span.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {opentelemetry.proto.trace.v1.ISpan} message Span message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Span.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.traceId != null && Object.hasOwnProperty.call(message, "traceId")) writer.uint32(10).bytes(message.traceId);
+ if (message.spanId != null && Object.hasOwnProperty.call(message, "spanId")) writer.uint32(18).bytes(message.spanId);
+ if (message.traceState != null && Object.hasOwnProperty.call(message, "traceState")) writer.uint32(26).string(message.traceState);
+ if (message.parentSpanId != null && Object.hasOwnProperty.call(message, "parentSpanId")) writer.uint32(34).bytes(message.parentSpanId);
+ if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(42).string(message.name);
+ if (message.kind != null && Object.hasOwnProperty.call(message, "kind")) writer.uint32(48).int32(message.kind);
+ if (message.startTimeUnixNano != null && Object.hasOwnProperty.call(message, "startTimeUnixNano")) writer.uint32(57).fixed64(message.startTimeUnixNano);
+ if (message.endTimeUnixNano != null && Object.hasOwnProperty.call(message, "endTimeUnixNano")) writer.uint32(65).fixed64(message.endTimeUnixNano);
+ if (message.attributes != null && message.attributes.length) for (var i = 0; i < message.attributes.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.attributes[i], writer.uint32(74).fork()).ldelim();
+ if (message.droppedAttributesCount != null && Object.hasOwnProperty.call(message, "droppedAttributesCount")) writer.uint32(80).uint32(message.droppedAttributesCount);
+ if (message.events != null && message.events.length) for (var i = 0; i < message.events.length; ++i) $root.opentelemetry.proto.trace.v1.Span.Event.encode(message.events[i], writer.uint32(90).fork()).ldelim();
+ if (message.droppedEventsCount != null && Object.hasOwnProperty.call(message, "droppedEventsCount")) writer.uint32(96).uint32(message.droppedEventsCount);
+ if (message.links != null && message.links.length) for (var i = 0; i < message.links.length; ++i) $root.opentelemetry.proto.trace.v1.Span.Link.encode(message.links[i], writer.uint32(106).fork()).ldelim();
+ if (message.droppedLinksCount != null && Object.hasOwnProperty.call(message, "droppedLinksCount")) writer.uint32(112).uint32(message.droppedLinksCount);
+ if (message.status != null && Object.hasOwnProperty.call(message, "status")) $root.opentelemetry.proto.trace.v1.Status.encode(message.status, writer.uint32(122).fork()).ldelim();
+ if (message.flags != null && Object.hasOwnProperty.call(message, "flags")) writer.uint32(133).fixed32(message.flags);
+ return writer;
+ };
+ /**
+ * Encodes the specified Span message, length delimited. Does not implicitly {@link opentelemetry.proto.trace.v1.Span.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {opentelemetry.proto.trace.v1.ISpan} message Span message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Span.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Span message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.trace.v1.Span} Span
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Span.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.Span();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.traceId = reader.bytes();
+ break;
+ case 2:
+ message.spanId = reader.bytes();
+ break;
+ case 3:
+ message.traceState = reader.string();
+ break;
+ case 4:
+ message.parentSpanId = reader.bytes();
+ break;
+ case 16:
+ message.flags = reader.fixed32();
+ break;
+ case 5:
+ message.name = reader.string();
+ break;
+ case 6:
+ message.kind = reader.int32();
+ break;
+ case 7:
+ message.startTimeUnixNano = reader.fixed64();
+ break;
+ case 8:
+ message.endTimeUnixNano = reader.fixed64();
+ break;
+ case 9:
+ if (!(message.attributes && message.attributes.length)) message.attributes = [];
+ message.attributes.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ case 10:
+ message.droppedAttributesCount = reader.uint32();
+ break;
+ case 11:
+ if (!(message.events && message.events.length)) message.events = [];
+ message.events.push($root.opentelemetry.proto.trace.v1.Span.Event.decode(reader, reader.uint32()));
+ break;
+ case 12:
+ message.droppedEventsCount = reader.uint32();
+ break;
+ case 13:
+ if (!(message.links && message.links.length)) message.links = [];
+ message.links.push($root.opentelemetry.proto.trace.v1.Span.Link.decode(reader, reader.uint32()));
+ break;
+ case 14:
+ message.droppedLinksCount = reader.uint32();
+ break;
+ case 15:
+ message.status = $root.opentelemetry.proto.trace.v1.Status.decode(reader, reader.uint32());
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Span message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.trace.v1.Span} Span
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Span.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Span message.
+ * @function verify
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Span.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.traceId != null && message.hasOwnProperty("traceId")) {
+ if (!(message.traceId && typeof message.traceId.length === "number" || $util.isString(message.traceId))) return "traceId: buffer expected";
+ }
+ if (message.spanId != null && message.hasOwnProperty("spanId")) {
+ if (!(message.spanId && typeof message.spanId.length === "number" || $util.isString(message.spanId))) return "spanId: buffer expected";
+ }
+ if (message.traceState != null && message.hasOwnProperty("traceState")) {
+ if (!$util.isString(message.traceState)) return "traceState: string expected";
+ }
+ if (message.parentSpanId != null && message.hasOwnProperty("parentSpanId")) {
+ if (!(message.parentSpanId && typeof message.parentSpanId.length === "number" || $util.isString(message.parentSpanId))) return "parentSpanId: buffer expected";
+ }
+ if (message.flags != null && message.hasOwnProperty("flags")) {
+ if (!$util.isInteger(message.flags)) return "flags: integer expected";
+ }
+ if (message.name != null && message.hasOwnProperty("name")) {
+ if (!$util.isString(message.name)) return "name: string expected";
+ }
+ if (message.kind != null && message.hasOwnProperty("kind")) switch (message.kind) {
+ default: return "kind: enum value expected";
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5: break;
+ }
+ if (message.startTimeUnixNano != null && message.hasOwnProperty("startTimeUnixNano")) {
+ if (!$util.isInteger(message.startTimeUnixNano) && !(message.startTimeUnixNano && $util.isInteger(message.startTimeUnixNano.low) && $util.isInteger(message.startTimeUnixNano.high))) return "startTimeUnixNano: integer|Long expected";
+ }
+ if (message.endTimeUnixNano != null && message.hasOwnProperty("endTimeUnixNano")) {
+ if (!$util.isInteger(message.endTimeUnixNano) && !(message.endTimeUnixNano && $util.isInteger(message.endTimeUnixNano.low) && $util.isInteger(message.endTimeUnixNano.high))) return "endTimeUnixNano: integer|Long expected";
+ }
+ if (message.attributes != null && message.hasOwnProperty("attributes")) {
+ if (!Array.isArray(message.attributes)) return "attributes: array expected";
+ for (var i = 0; i < message.attributes.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.attributes[i]);
+ if (error) return "attributes." + error;
+ }
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) {
+ if (!$util.isInteger(message.droppedAttributesCount)) return "droppedAttributesCount: integer expected";
+ }
+ if (message.events != null && message.hasOwnProperty("events")) {
+ if (!Array.isArray(message.events)) return "events: array expected";
+ for (var i = 0; i < message.events.length; ++i) {
+ var error = $root.opentelemetry.proto.trace.v1.Span.Event.verify(message.events[i]);
+ if (error) return "events." + error;
+ }
+ }
+ if (message.droppedEventsCount != null && message.hasOwnProperty("droppedEventsCount")) {
+ if (!$util.isInteger(message.droppedEventsCount)) return "droppedEventsCount: integer expected";
+ }
+ if (message.links != null && message.hasOwnProperty("links")) {
+ if (!Array.isArray(message.links)) return "links: array expected";
+ for (var i = 0; i < message.links.length; ++i) {
+ var error = $root.opentelemetry.proto.trace.v1.Span.Link.verify(message.links[i]);
+ if (error) return "links." + error;
+ }
+ }
+ if (message.droppedLinksCount != null && message.hasOwnProperty("droppedLinksCount")) {
+ if (!$util.isInteger(message.droppedLinksCount)) return "droppedLinksCount: integer expected";
+ }
+ if (message.status != null && message.hasOwnProperty("status")) {
+ var error = $root.opentelemetry.proto.trace.v1.Status.verify(message.status);
+ if (error) return "status." + error;
+ }
+ return null;
+ };
+ /**
+ * Creates a Span message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.trace.v1.Span} Span
+ */
+ Span.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.trace.v1.Span) return object;
+ var message = new $root.opentelemetry.proto.trace.v1.Span();
+ if (object.traceId != null) {
+ if (typeof object.traceId === "string") $util.base64.decode(object.traceId, message.traceId = $util.newBuffer($util.base64.length(object.traceId)), 0);
+ else if (object.traceId.length >= 0) message.traceId = object.traceId;
+ }
+ if (object.spanId != null) {
+ if (typeof object.spanId === "string") $util.base64.decode(object.spanId, message.spanId = $util.newBuffer($util.base64.length(object.spanId)), 0);
+ else if (object.spanId.length >= 0) message.spanId = object.spanId;
+ }
+ if (object.traceState != null) message.traceState = String(object.traceState);
+ if (object.parentSpanId != null) {
+ if (typeof object.parentSpanId === "string") $util.base64.decode(object.parentSpanId, message.parentSpanId = $util.newBuffer($util.base64.length(object.parentSpanId)), 0);
+ else if (object.parentSpanId.length >= 0) message.parentSpanId = object.parentSpanId;
+ }
+ if (object.flags != null) message.flags = object.flags >>> 0;
+ if (object.name != null) message.name = String(object.name);
+ switch (object.kind) {
+ default:
+ if (typeof object.kind === "number") {
+ message.kind = object.kind;
+ break;
+ }
+ break;
+ case "SPAN_KIND_UNSPECIFIED":
+ case 0:
+ message.kind = 0;
+ break;
+ case "SPAN_KIND_INTERNAL":
+ case 1:
+ message.kind = 1;
+ break;
+ case "SPAN_KIND_SERVER":
+ case 2:
+ message.kind = 2;
+ break;
+ case "SPAN_KIND_CLIENT":
+ case 3:
+ message.kind = 3;
+ break;
+ case "SPAN_KIND_PRODUCER":
+ case 4:
+ message.kind = 4;
+ break;
+ case "SPAN_KIND_CONSUMER":
+ case 5:
+ message.kind = 5;
+ break;
+ }
+ if (object.startTimeUnixNano != null) {
+ if ($util.Long) (message.startTimeUnixNano = $util.Long.fromValue(object.startTimeUnixNano)).unsigned = false;
+ else if (typeof object.startTimeUnixNano === "string") message.startTimeUnixNano = parseInt(object.startTimeUnixNano, 10);
+ else if (typeof object.startTimeUnixNano === "number") message.startTimeUnixNano = object.startTimeUnixNano;
+ else if (typeof object.startTimeUnixNano === "object") message.startTimeUnixNano = new $util.LongBits(object.startTimeUnixNano.low >>> 0, object.startTimeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.endTimeUnixNano != null) {
+ if ($util.Long) (message.endTimeUnixNano = $util.Long.fromValue(object.endTimeUnixNano)).unsigned = false;
+ else if (typeof object.endTimeUnixNano === "string") message.endTimeUnixNano = parseInt(object.endTimeUnixNano, 10);
+ else if (typeof object.endTimeUnixNano === "number") message.endTimeUnixNano = object.endTimeUnixNano;
+ else if (typeof object.endTimeUnixNano === "object") message.endTimeUnixNano = new $util.LongBits(object.endTimeUnixNano.low >>> 0, object.endTimeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.attributes) {
+ if (!Array.isArray(object.attributes)) throw TypeError(".opentelemetry.proto.trace.v1.Span.attributes: array expected");
+ message.attributes = [];
+ for (var i = 0; i < object.attributes.length; ++i) {
+ if (typeof object.attributes[i] !== "object") throw TypeError(".opentelemetry.proto.trace.v1.Span.attributes: object expected");
+ message.attributes[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.attributes[i]);
+ }
+ }
+ if (object.droppedAttributesCount != null) message.droppedAttributesCount = object.droppedAttributesCount >>> 0;
+ if (object.events) {
+ if (!Array.isArray(object.events)) throw TypeError(".opentelemetry.proto.trace.v1.Span.events: array expected");
+ message.events = [];
+ for (var i = 0; i < object.events.length; ++i) {
+ if (typeof object.events[i] !== "object") throw TypeError(".opentelemetry.proto.trace.v1.Span.events: object expected");
+ message.events[i] = $root.opentelemetry.proto.trace.v1.Span.Event.fromObject(object.events[i]);
+ }
+ }
+ if (object.droppedEventsCount != null) message.droppedEventsCount = object.droppedEventsCount >>> 0;
+ if (object.links) {
+ if (!Array.isArray(object.links)) throw TypeError(".opentelemetry.proto.trace.v1.Span.links: array expected");
+ message.links = [];
+ for (var i = 0; i < object.links.length; ++i) {
+ if (typeof object.links[i] !== "object") throw TypeError(".opentelemetry.proto.trace.v1.Span.links: object expected");
+ message.links[i] = $root.opentelemetry.proto.trace.v1.Span.Link.fromObject(object.links[i]);
+ }
+ }
+ if (object.droppedLinksCount != null) message.droppedLinksCount = object.droppedLinksCount >>> 0;
+ if (object.status != null) {
+ if (typeof object.status !== "object") throw TypeError(".opentelemetry.proto.trace.v1.Span.status: object expected");
+ message.status = $root.opentelemetry.proto.trace.v1.Status.fromObject(object.status);
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a Span message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span} message Span
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Span.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) {
+ object.attributes = [];
+ object.events = [];
+ object.links = [];
+ }
+ if (options.defaults) {
+ if (options.bytes === String) object.traceId = "";
+ else {
+ object.traceId = [];
+ if (options.bytes !== Array) object.traceId = $util.newBuffer(object.traceId);
+ }
+ if (options.bytes === String) object.spanId = "";
+ else {
+ object.spanId = [];
+ if (options.bytes !== Array) object.spanId = $util.newBuffer(object.spanId);
+ }
+ object.traceState = "";
+ if (options.bytes === String) object.parentSpanId = "";
+ else {
+ object.parentSpanId = [];
+ if (options.bytes !== Array) object.parentSpanId = $util.newBuffer(object.parentSpanId);
+ }
+ object.name = "";
+ object.kind = options.enums === String ? "SPAN_KIND_UNSPECIFIED" : 0;
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.startTimeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.startTimeUnixNano = options.longs === String ? "0" : 0;
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.endTimeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.endTimeUnixNano = options.longs === String ? "0" : 0;
+ object.droppedAttributesCount = 0;
+ object.droppedEventsCount = 0;
+ object.droppedLinksCount = 0;
+ object.status = null;
+ object.flags = 0;
+ }
+ if (message.traceId != null && message.hasOwnProperty("traceId")) object.traceId = options.bytes === String ? $util.base64.encode(message.traceId, 0, message.traceId.length) : options.bytes === Array ? Array.prototype.slice.call(message.traceId) : message.traceId;
+ if (message.spanId != null && message.hasOwnProperty("spanId")) object.spanId = options.bytes === String ? $util.base64.encode(message.spanId, 0, message.spanId.length) : options.bytes === Array ? Array.prototype.slice.call(message.spanId) : message.spanId;
+ if (message.traceState != null && message.hasOwnProperty("traceState")) object.traceState = message.traceState;
+ if (message.parentSpanId != null && message.hasOwnProperty("parentSpanId")) object.parentSpanId = options.bytes === String ? $util.base64.encode(message.parentSpanId, 0, message.parentSpanId.length) : options.bytes === Array ? Array.prototype.slice.call(message.parentSpanId) : message.parentSpanId;
+ if (message.name != null && message.hasOwnProperty("name")) object.name = message.name;
+ if (message.kind != null && message.hasOwnProperty("kind")) object.kind = options.enums === String ? $root.opentelemetry.proto.trace.v1.Span.SpanKind[message.kind] === void 0 ? message.kind : $root.opentelemetry.proto.trace.v1.Span.SpanKind[message.kind] : message.kind;
+ if (message.startTimeUnixNano != null && message.hasOwnProperty("startTimeUnixNano")) if (typeof message.startTimeUnixNano === "number") object.startTimeUnixNano = options.longs === String ? String(message.startTimeUnixNano) : message.startTimeUnixNano;
+ else object.startTimeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.startTimeUnixNano) : options.longs === Number ? new $util.LongBits(message.startTimeUnixNano.low >>> 0, message.startTimeUnixNano.high >>> 0).toNumber() : message.startTimeUnixNano;
+ if (message.endTimeUnixNano != null && message.hasOwnProperty("endTimeUnixNano")) if (typeof message.endTimeUnixNano === "number") object.endTimeUnixNano = options.longs === String ? String(message.endTimeUnixNano) : message.endTimeUnixNano;
+ else object.endTimeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.endTimeUnixNano) : options.longs === Number ? new $util.LongBits(message.endTimeUnixNano.low >>> 0, message.endTimeUnixNano.high >>> 0).toNumber() : message.endTimeUnixNano;
+ if (message.attributes && message.attributes.length) {
+ object.attributes = [];
+ for (var j = 0; j < message.attributes.length; ++j) object.attributes[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.attributes[j], options);
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) object.droppedAttributesCount = message.droppedAttributesCount;
+ if (message.events && message.events.length) {
+ object.events = [];
+ for (var j = 0; j < message.events.length; ++j) object.events[j] = $root.opentelemetry.proto.trace.v1.Span.Event.toObject(message.events[j], options);
+ }
+ if (message.droppedEventsCount != null && message.hasOwnProperty("droppedEventsCount")) object.droppedEventsCount = message.droppedEventsCount;
+ if (message.links && message.links.length) {
+ object.links = [];
+ for (var j = 0; j < message.links.length; ++j) object.links[j] = $root.opentelemetry.proto.trace.v1.Span.Link.toObject(message.links[j], options);
+ }
+ if (message.droppedLinksCount != null && message.hasOwnProperty("droppedLinksCount")) object.droppedLinksCount = message.droppedLinksCount;
+ if (message.status != null && message.hasOwnProperty("status")) object.status = $root.opentelemetry.proto.trace.v1.Status.toObject(message.status, options);
+ if (message.flags != null && message.hasOwnProperty("flags")) object.flags = message.flags;
+ return object;
+ };
+ /**
+ * Converts this Span to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Span.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Span
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Span.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.trace.v1.Span";
+ };
+ /**
+ * SpanKind enum.
+ * @name opentelemetry.proto.trace.v1.Span.SpanKind
+ * @enum {number}
+ * @property {number} SPAN_KIND_UNSPECIFIED=0 SPAN_KIND_UNSPECIFIED value
+ * @property {number} SPAN_KIND_INTERNAL=1 SPAN_KIND_INTERNAL value
+ * @property {number} SPAN_KIND_SERVER=2 SPAN_KIND_SERVER value
+ * @property {number} SPAN_KIND_CLIENT=3 SPAN_KIND_CLIENT value
+ * @property {number} SPAN_KIND_PRODUCER=4 SPAN_KIND_PRODUCER value
+ * @property {number} SPAN_KIND_CONSUMER=5 SPAN_KIND_CONSUMER value
+ */
+ Span.SpanKind = (function() {
+ var valuesById = {}, values = Object.create(valuesById);
+ values[valuesById[0] = "SPAN_KIND_UNSPECIFIED"] = 0;
+ values[valuesById[1] = "SPAN_KIND_INTERNAL"] = 1;
+ values[valuesById[2] = "SPAN_KIND_SERVER"] = 2;
+ values[valuesById[3] = "SPAN_KIND_CLIENT"] = 3;
+ values[valuesById[4] = "SPAN_KIND_PRODUCER"] = 4;
+ values[valuesById[5] = "SPAN_KIND_CONSUMER"] = 5;
+ return values;
+ })();
+ Span.Event = (function() {
+ /**
+ * Properties of an Event.
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @interface IEvent
+ * @property {number|Long|null} [timeUnixNano] Event timeUnixNano
+ * @property {string|null} [name] Event name
+ * @property {Array.|null} [attributes] Event attributes
+ * @property {number|null} [droppedAttributesCount] Event droppedAttributesCount
+ */
+ /**
+ * Constructs a new Event.
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @classdesc Represents an Event.
+ * @implements IEvent
+ * @constructor
+ * @param {opentelemetry.proto.trace.v1.Span.IEvent=} [properties] Properties to set
+ */
+ function Event(properties) {
+ this.attributes = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Event timeUnixNano.
+ * @member {number|Long|null|undefined} timeUnixNano
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @instance
+ */
+ Event.prototype.timeUnixNano = null;
+ /**
+ * Event name.
+ * @member {string|null|undefined} name
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @instance
+ */
+ Event.prototype.name = null;
+ /**
+ * Event attributes.
+ * @member {Array.} attributes
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @instance
+ */
+ Event.prototype.attributes = $util.emptyArray;
+ /**
+ * Event droppedAttributesCount.
+ * @member {number|null|undefined} droppedAttributesCount
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @instance
+ */
+ Event.prototype.droppedAttributesCount = null;
+ /**
+ * Creates a new Event instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span.IEvent=} [properties] Properties to set
+ * @returns {opentelemetry.proto.trace.v1.Span.Event} Event instance
+ */
+ Event.create = function create(properties) {
+ return new Event(properties);
+ };
+ /**
+ * Encodes the specified Event message. Does not implicitly {@link opentelemetry.proto.trace.v1.Span.Event.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span.IEvent} message Event message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Event.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.timeUnixNano != null && Object.hasOwnProperty.call(message, "timeUnixNano")) writer.uint32(9).fixed64(message.timeUnixNano);
+ if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(18).string(message.name);
+ if (message.attributes != null && message.attributes.length) for (var i = 0; i < message.attributes.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.attributes[i], writer.uint32(26).fork()).ldelim();
+ if (message.droppedAttributesCount != null && Object.hasOwnProperty.call(message, "droppedAttributesCount")) writer.uint32(32).uint32(message.droppedAttributesCount);
+ return writer;
+ };
+ /**
+ * Encodes the specified Event message, length delimited. Does not implicitly {@link opentelemetry.proto.trace.v1.Span.Event.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span.IEvent} message Event message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Event.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an Event message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.trace.v1.Span.Event} Event
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Event.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.Span.Event();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.timeUnixNano = reader.fixed64();
+ break;
+ case 2:
+ message.name = reader.string();
+ break;
+ case 3:
+ if (!(message.attributes && message.attributes.length)) message.attributes = [];
+ message.attributes.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ case 4:
+ message.droppedAttributesCount = reader.uint32();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an Event message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.trace.v1.Span.Event} Event
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Event.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an Event message.
+ * @function verify
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Event.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) {
+ if (!$util.isInteger(message.timeUnixNano) && !(message.timeUnixNano && $util.isInteger(message.timeUnixNano.low) && $util.isInteger(message.timeUnixNano.high))) return "timeUnixNano: integer|Long expected";
+ }
+ if (message.name != null && message.hasOwnProperty("name")) {
+ if (!$util.isString(message.name)) return "name: string expected";
+ }
+ if (message.attributes != null && message.hasOwnProperty("attributes")) {
+ if (!Array.isArray(message.attributes)) return "attributes: array expected";
+ for (var i = 0; i < message.attributes.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.attributes[i]);
+ if (error) return "attributes." + error;
+ }
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) {
+ if (!$util.isInteger(message.droppedAttributesCount)) return "droppedAttributesCount: integer expected";
+ }
+ return null;
+ };
+ /**
+ * Creates an Event message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.trace.v1.Span.Event} Event
+ */
+ Event.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.trace.v1.Span.Event) return object;
+ var message = new $root.opentelemetry.proto.trace.v1.Span.Event();
+ if (object.timeUnixNano != null) {
+ if ($util.Long) (message.timeUnixNano = $util.Long.fromValue(object.timeUnixNano)).unsigned = false;
+ else if (typeof object.timeUnixNano === "string") message.timeUnixNano = parseInt(object.timeUnixNano, 10);
+ else if (typeof object.timeUnixNano === "number") message.timeUnixNano = object.timeUnixNano;
+ else if (typeof object.timeUnixNano === "object") message.timeUnixNano = new $util.LongBits(object.timeUnixNano.low >>> 0, object.timeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.name != null) message.name = String(object.name);
+ if (object.attributes) {
+ if (!Array.isArray(object.attributes)) throw TypeError(".opentelemetry.proto.trace.v1.Span.Event.attributes: array expected");
+ message.attributes = [];
+ for (var i = 0; i < object.attributes.length; ++i) {
+ if (typeof object.attributes[i] !== "object") throw TypeError(".opentelemetry.proto.trace.v1.Span.Event.attributes: object expected");
+ message.attributes[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.attributes[i]);
+ }
+ }
+ if (object.droppedAttributesCount != null) message.droppedAttributesCount = object.droppedAttributesCount >>> 0;
+ return message;
+ };
+ /**
+ * Creates a plain object from an Event message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span.Event} message Event
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Event.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.attributes = [];
+ if (options.defaults) {
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.timeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.timeUnixNano = options.longs === String ? "0" : 0;
+ object.name = "";
+ object.droppedAttributesCount = 0;
+ }
+ if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) if (typeof message.timeUnixNano === "number") object.timeUnixNano = options.longs === String ? String(message.timeUnixNano) : message.timeUnixNano;
+ else object.timeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.timeUnixNano) : options.longs === Number ? new $util.LongBits(message.timeUnixNano.low >>> 0, message.timeUnixNano.high >>> 0).toNumber() : message.timeUnixNano;
+ if (message.name != null && message.hasOwnProperty("name")) object.name = message.name;
+ if (message.attributes && message.attributes.length) {
+ object.attributes = [];
+ for (var j = 0; j < message.attributes.length; ++j) object.attributes[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.attributes[j], options);
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) object.droppedAttributesCount = message.droppedAttributesCount;
+ return object;
+ };
+ /**
+ * Converts this Event to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Event.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Event
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.trace.v1.Span.Event
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Event.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.trace.v1.Span.Event";
+ };
+ return Event;
+ })();
+ Span.Link = (function() {
+ /**
+ * Properties of a Link.
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @interface ILink
+ * @property {Uint8Array|null} [traceId] Link traceId
+ * @property {Uint8Array|null} [spanId] Link spanId
+ * @property {string|null} [traceState] Link traceState
+ * @property {Array.|null} [attributes] Link attributes
+ * @property {number|null} [droppedAttributesCount] Link droppedAttributesCount
+ * @property {number|null} [flags] Link flags
+ */
+ /**
+ * Constructs a new Link.
+ * @memberof opentelemetry.proto.trace.v1.Span
+ * @classdesc Represents a Link.
+ * @implements ILink
+ * @constructor
+ * @param {opentelemetry.proto.trace.v1.Span.ILink=} [properties] Properties to set
+ */
+ function Link(properties) {
+ this.attributes = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Link traceId.
+ * @member {Uint8Array|null|undefined} traceId
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @instance
+ */
+ Link.prototype.traceId = null;
+ /**
+ * Link spanId.
+ * @member {Uint8Array|null|undefined} spanId
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @instance
+ */
+ Link.prototype.spanId = null;
+ /**
+ * Link traceState.
+ * @member {string|null|undefined} traceState
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @instance
+ */
+ Link.prototype.traceState = null;
+ /**
+ * Link attributes.
+ * @member {Array.} attributes
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @instance
+ */
+ Link.prototype.attributes = $util.emptyArray;
+ /**
+ * Link droppedAttributesCount.
+ * @member {number|null|undefined} droppedAttributesCount
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @instance
+ */
+ Link.prototype.droppedAttributesCount = null;
+ /**
+ * Link flags.
+ * @member {number|null|undefined} flags
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @instance
+ */
+ Link.prototype.flags = null;
+ /**
+ * Creates a new Link instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span.ILink=} [properties] Properties to set
+ * @returns {opentelemetry.proto.trace.v1.Span.Link} Link instance
+ */
+ Link.create = function create(properties) {
+ return new Link(properties);
+ };
+ /**
+ * Encodes the specified Link message. Does not implicitly {@link opentelemetry.proto.trace.v1.Span.Link.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span.ILink} message Link message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Link.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.traceId != null && Object.hasOwnProperty.call(message, "traceId")) writer.uint32(10).bytes(message.traceId);
+ if (message.spanId != null && Object.hasOwnProperty.call(message, "spanId")) writer.uint32(18).bytes(message.spanId);
+ if (message.traceState != null && Object.hasOwnProperty.call(message, "traceState")) writer.uint32(26).string(message.traceState);
+ if (message.attributes != null && message.attributes.length) for (var i = 0; i < message.attributes.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.attributes[i], writer.uint32(34).fork()).ldelim();
+ if (message.droppedAttributesCount != null && Object.hasOwnProperty.call(message, "droppedAttributesCount")) writer.uint32(40).uint32(message.droppedAttributesCount);
+ if (message.flags != null && Object.hasOwnProperty.call(message, "flags")) writer.uint32(53).fixed32(message.flags);
+ return writer;
+ };
+ /**
+ * Encodes the specified Link message, length delimited. Does not implicitly {@link opentelemetry.proto.trace.v1.Span.Link.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span.ILink} message Link message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Link.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Link message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.trace.v1.Span.Link} Link
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Link.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.Span.Link();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.traceId = reader.bytes();
+ break;
+ case 2:
+ message.spanId = reader.bytes();
+ break;
+ case 3:
+ message.traceState = reader.string();
+ break;
+ case 4:
+ if (!(message.attributes && message.attributes.length)) message.attributes = [];
+ message.attributes.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ case 5:
+ message.droppedAttributesCount = reader.uint32();
+ break;
+ case 6:
+ message.flags = reader.fixed32();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Link message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.trace.v1.Span.Link} Link
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Link.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Link message.
+ * @function verify
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Link.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.traceId != null && message.hasOwnProperty("traceId")) {
+ if (!(message.traceId && typeof message.traceId.length === "number" || $util.isString(message.traceId))) return "traceId: buffer expected";
+ }
+ if (message.spanId != null && message.hasOwnProperty("spanId")) {
+ if (!(message.spanId && typeof message.spanId.length === "number" || $util.isString(message.spanId))) return "spanId: buffer expected";
+ }
+ if (message.traceState != null && message.hasOwnProperty("traceState")) {
+ if (!$util.isString(message.traceState)) return "traceState: string expected";
+ }
+ if (message.attributes != null && message.hasOwnProperty("attributes")) {
+ if (!Array.isArray(message.attributes)) return "attributes: array expected";
+ for (var i = 0; i < message.attributes.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.attributes[i]);
+ if (error) return "attributes." + error;
+ }
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) {
+ if (!$util.isInteger(message.droppedAttributesCount)) return "droppedAttributesCount: integer expected";
+ }
+ if (message.flags != null && message.hasOwnProperty("flags")) {
+ if (!$util.isInteger(message.flags)) return "flags: integer expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a Link message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.trace.v1.Span.Link} Link
+ */
+ Link.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.trace.v1.Span.Link) return object;
+ var message = new $root.opentelemetry.proto.trace.v1.Span.Link();
+ if (object.traceId != null) {
+ if (typeof object.traceId === "string") $util.base64.decode(object.traceId, message.traceId = $util.newBuffer($util.base64.length(object.traceId)), 0);
+ else if (object.traceId.length >= 0) message.traceId = object.traceId;
+ }
+ if (object.spanId != null) {
+ if (typeof object.spanId === "string") $util.base64.decode(object.spanId, message.spanId = $util.newBuffer($util.base64.length(object.spanId)), 0);
+ else if (object.spanId.length >= 0) message.spanId = object.spanId;
+ }
+ if (object.traceState != null) message.traceState = String(object.traceState);
+ if (object.attributes) {
+ if (!Array.isArray(object.attributes)) throw TypeError(".opentelemetry.proto.trace.v1.Span.Link.attributes: array expected");
+ message.attributes = [];
+ for (var i = 0; i < object.attributes.length; ++i) {
+ if (typeof object.attributes[i] !== "object") throw TypeError(".opentelemetry.proto.trace.v1.Span.Link.attributes: object expected");
+ message.attributes[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.attributes[i]);
+ }
+ }
+ if (object.droppedAttributesCount != null) message.droppedAttributesCount = object.droppedAttributesCount >>> 0;
+ if (object.flags != null) message.flags = object.flags >>> 0;
+ return message;
+ };
+ /**
+ * Creates a plain object from a Link message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Span.Link} message Link
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Link.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.attributes = [];
+ if (options.defaults) {
+ if (options.bytes === String) object.traceId = "";
+ else {
+ object.traceId = [];
+ if (options.bytes !== Array) object.traceId = $util.newBuffer(object.traceId);
+ }
+ if (options.bytes === String) object.spanId = "";
+ else {
+ object.spanId = [];
+ if (options.bytes !== Array) object.spanId = $util.newBuffer(object.spanId);
+ }
+ object.traceState = "";
+ object.droppedAttributesCount = 0;
+ object.flags = 0;
+ }
+ if (message.traceId != null && message.hasOwnProperty("traceId")) object.traceId = options.bytes === String ? $util.base64.encode(message.traceId, 0, message.traceId.length) : options.bytes === Array ? Array.prototype.slice.call(message.traceId) : message.traceId;
+ if (message.spanId != null && message.hasOwnProperty("spanId")) object.spanId = options.bytes === String ? $util.base64.encode(message.spanId, 0, message.spanId.length) : options.bytes === Array ? Array.prototype.slice.call(message.spanId) : message.spanId;
+ if (message.traceState != null && message.hasOwnProperty("traceState")) object.traceState = message.traceState;
+ if (message.attributes && message.attributes.length) {
+ object.attributes = [];
+ for (var j = 0; j < message.attributes.length; ++j) object.attributes[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.attributes[j], options);
+ }
+ if (message.droppedAttributesCount != null && message.hasOwnProperty("droppedAttributesCount")) object.droppedAttributesCount = message.droppedAttributesCount;
+ if (message.flags != null && message.hasOwnProperty("flags")) object.flags = message.flags;
+ return object;
+ };
+ /**
+ * Converts this Link to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Link.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Link
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.trace.v1.Span.Link
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Link.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.trace.v1.Span.Link";
+ };
+ return Link;
+ })();
+ return Span;
+ })();
+ v1.Status = (function() {
+ /**
+ * Properties of a Status.
+ * @memberof opentelemetry.proto.trace.v1
+ * @interface IStatus
+ * @property {string|null} [message] Status message
+ * @property {opentelemetry.proto.trace.v1.Status.StatusCode|null} [code] Status code
+ */
+ /**
+ * Constructs a new Status.
+ * @memberof opentelemetry.proto.trace.v1
+ * @classdesc Represents a Status.
+ * @implements IStatus
+ * @constructor
+ * @param {opentelemetry.proto.trace.v1.IStatus=} [properties] Properties to set
+ */
+ function Status(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Status message.
+ * @member {string|null|undefined} message
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @instance
+ */
+ Status.prototype.message = null;
+ /**
+ * Status code.
+ * @member {opentelemetry.proto.trace.v1.Status.StatusCode|null|undefined} code
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @instance
+ */
+ Status.prototype.code = null;
+ /**
+ * Creates a new Status instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IStatus=} [properties] Properties to set
+ * @returns {opentelemetry.proto.trace.v1.Status} Status instance
+ */
+ Status.create = function create(properties) {
+ return new Status(properties);
+ };
+ /**
+ * Encodes the specified Status message. Does not implicitly {@link opentelemetry.proto.trace.v1.Status.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IStatus} message Status message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Status.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.message != null && Object.hasOwnProperty.call(message, "message")) writer.uint32(18).string(message.message);
+ if (message.code != null && Object.hasOwnProperty.call(message, "code")) writer.uint32(24).int32(message.code);
+ return writer;
+ };
+ /**
+ * Encodes the specified Status message, length delimited. Does not implicitly {@link opentelemetry.proto.trace.v1.Status.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {opentelemetry.proto.trace.v1.IStatus} message Status message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Status.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Status message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.trace.v1.Status} Status
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Status.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.Status();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 2:
+ message.message = reader.string();
+ break;
+ case 3:
+ message.code = reader.int32();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Status message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.trace.v1.Status} Status
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Status.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Status message.
+ * @function verify
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Status.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.message != null && message.hasOwnProperty("message")) {
+ if (!$util.isString(message.message)) return "message: string expected";
+ }
+ if (message.code != null && message.hasOwnProperty("code")) switch (message.code) {
+ default: return "code: enum value expected";
+ case 0:
+ case 1:
+ case 2: break;
+ }
+ return null;
+ };
+ /**
+ * Creates a Status message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.trace.v1.Status} Status
+ */
+ Status.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.trace.v1.Status) return object;
+ var message = new $root.opentelemetry.proto.trace.v1.Status();
+ if (object.message != null) message.message = String(object.message);
+ switch (object.code) {
+ default:
+ if (typeof object.code === "number") {
+ message.code = object.code;
+ break;
+ }
+ break;
+ case "STATUS_CODE_UNSET":
+ case 0:
+ message.code = 0;
+ break;
+ case "STATUS_CODE_OK":
+ case 1:
+ message.code = 1;
+ break;
+ case "STATUS_CODE_ERROR":
+ case 2:
+ message.code = 2;
+ break;
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a Status message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {opentelemetry.proto.trace.v1.Status} message Status
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Status.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.defaults) {
+ object.message = "";
+ object.code = options.enums === String ? "STATUS_CODE_UNSET" : 0;
+ }
+ if (message.message != null && message.hasOwnProperty("message")) object.message = message.message;
+ if (message.code != null && message.hasOwnProperty("code")) object.code = options.enums === String ? $root.opentelemetry.proto.trace.v1.Status.StatusCode[message.code] === void 0 ? message.code : $root.opentelemetry.proto.trace.v1.Status.StatusCode[message.code] : message.code;
+ return object;
+ };
+ /**
+ * Converts this Status to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Status.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Status
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.trace.v1.Status
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Status.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.trace.v1.Status";
+ };
+ /**
+ * StatusCode enum.
+ * @name opentelemetry.proto.trace.v1.Status.StatusCode
+ * @enum {number}
+ * @property {number} STATUS_CODE_UNSET=0 STATUS_CODE_UNSET value
+ * @property {number} STATUS_CODE_OK=1 STATUS_CODE_OK value
+ * @property {number} STATUS_CODE_ERROR=2 STATUS_CODE_ERROR value
+ */
+ Status.StatusCode = (function() {
+ var valuesById = {}, values = Object.create(valuesById);
+ values[valuesById[0] = "STATUS_CODE_UNSET"] = 0;
+ values[valuesById[1] = "STATUS_CODE_OK"] = 1;
+ values[valuesById[2] = "STATUS_CODE_ERROR"] = 2;
+ return values;
+ })();
+ return Status;
+ })();
+ /**
+ * SpanFlags enum.
+ * @name opentelemetry.proto.trace.v1.SpanFlags
+ * @enum {number}
+ * @property {number} SPAN_FLAGS_DO_NOT_USE=0 SPAN_FLAGS_DO_NOT_USE value
+ * @property {number} SPAN_FLAGS_TRACE_FLAGS_MASK=255 SPAN_FLAGS_TRACE_FLAGS_MASK value
+ * @property {number} SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK=256 SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK value
+ * @property {number} SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK=512 SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK value
+ */
+ v1.SpanFlags = (function() {
+ var valuesById = {}, values = Object.create(valuesById);
+ values[valuesById[0] = "SPAN_FLAGS_DO_NOT_USE"] = 0;
+ values[valuesById[255] = "SPAN_FLAGS_TRACE_FLAGS_MASK"] = 255;
+ values[valuesById[256] = "SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK"] = 256;
+ values[valuesById[512] = "SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK"] = 512;
+ return values;
+ })();
+ return v1;
+ })();
+ return trace$1;
+ })();
+ proto.collector = (function() {
+ /**
+ * Namespace collector.
+ * @memberof opentelemetry.proto
+ * @namespace
+ */
+ var collector = {};
+ collector.trace = (function() {
+ /**
+ * Namespace trace.
+ * @memberof opentelemetry.proto.collector
+ * @namespace
+ */
+ var trace$1 = {};
+ trace$1.v1 = (function() {
+ /**
+ * Namespace v1.
+ * @memberof opentelemetry.proto.collector.trace
+ * @namespace
+ */
+ var v1 = {};
+ v1.TraceService = (function() {
+ /**
+ * Constructs a new TraceService service.
+ * @memberof opentelemetry.proto.collector.trace.v1
+ * @classdesc Represents a TraceService
+ * @extends $protobuf.rpc.Service
+ * @constructor
+ * @param {$protobuf.RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ */
+ function TraceService(rpcImpl, requestDelimited, responseDelimited) {
+ $protobuf.rpc.Service.call(this, rpcImpl, requestDelimited, responseDelimited);
+ }
+ (TraceService.prototype = Object.create($protobuf.rpc.Service.prototype)).constructor = TraceService;
+ /**
+ * Creates new TraceService service using the specified rpc implementation.
+ * @function create
+ * @memberof opentelemetry.proto.collector.trace.v1.TraceService
+ * @static
+ * @param {$protobuf.RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ * @returns {TraceService} RPC service. Useful where requests and/or responses are streamed.
+ */
+ TraceService.create = function create(rpcImpl, requestDelimited, responseDelimited) {
+ return new this(rpcImpl, requestDelimited, responseDelimited);
+ };
+ /**
+ * Callback as used by {@link opentelemetry.proto.collector.trace.v1.TraceService#export_}.
+ * @memberof opentelemetry.proto.collector.trace.v1.TraceService
+ * @typedef ExportCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} [response] ExportTraceServiceResponse
+ */
+ /**
+ * Calls Export.
+ * @function export
+ * @memberof opentelemetry.proto.collector.trace.v1.TraceService
+ * @instance
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceRequest} request ExportTraceServiceRequest message or plain object
+ * @param {opentelemetry.proto.collector.trace.v1.TraceService.ExportCallback} callback Node-style callback called with the error, if any, and ExportTraceServiceResponse
+ * @returns {undefined}
+ * @variation 1
+ */
+ Object.defineProperty(TraceService.prototype["export"] = function export_(request, callback) {
+ return this.rpcCall(export_, $root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest, $root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse, request, callback);
+ }, "name", { value: "Export" });
+ /**
+ * Calls Export.
+ * @function export
+ * @memberof opentelemetry.proto.collector.trace.v1.TraceService
+ * @instance
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceRequest} request ExportTraceServiceRequest message or plain object
+ * @returns {Promise} Promise
+ * @variation 2
+ */
+ return TraceService;
+ })();
+ v1.ExportTraceServiceRequest = (function() {
+ /**
+ * Properties of an ExportTraceServiceRequest.
+ * @memberof opentelemetry.proto.collector.trace.v1
+ * @interface IExportTraceServiceRequest
+ * @property {Array.|null} [resourceSpans] ExportTraceServiceRequest resourceSpans
+ */
+ /**
+ * Constructs a new ExportTraceServiceRequest.
+ * @memberof opentelemetry.proto.collector.trace.v1
+ * @classdesc Represents an ExportTraceServiceRequest.
+ * @implements IExportTraceServiceRequest
+ * @constructor
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceRequest=} [properties] Properties to set
+ */
+ function ExportTraceServiceRequest(properties) {
+ this.resourceSpans = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportTraceServiceRequest resourceSpans.
+ * @member {Array.} resourceSpans
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @instance
+ */
+ ExportTraceServiceRequest.prototype.resourceSpans = $util.emptyArray;
+ /**
+ * Creates a new ExportTraceServiceRequest instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceRequest=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} ExportTraceServiceRequest instance
+ */
+ ExportTraceServiceRequest.create = function create(properties) {
+ return new ExportTraceServiceRequest(properties);
+ };
+ /**
+ * Encodes the specified ExportTraceServiceRequest message. Does not implicitly {@link opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceRequest} message ExportTraceServiceRequest message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportTraceServiceRequest.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.resourceSpans != null && message.resourceSpans.length) for (var i = 0; i < message.resourceSpans.length; ++i) $root.opentelemetry.proto.trace.v1.ResourceSpans.encode(message.resourceSpans[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportTraceServiceRequest message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceRequest} message ExportTraceServiceRequest message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportTraceServiceRequest.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportTraceServiceRequest message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} ExportTraceServiceRequest
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportTraceServiceRequest.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.resourceSpans && message.resourceSpans.length)) message.resourceSpans = [];
+ message.resourceSpans.push($root.opentelemetry.proto.trace.v1.ResourceSpans.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportTraceServiceRequest message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} ExportTraceServiceRequest
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportTraceServiceRequest.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportTraceServiceRequest message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportTraceServiceRequest.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.resourceSpans != null && message.hasOwnProperty("resourceSpans")) {
+ if (!Array.isArray(message.resourceSpans)) return "resourceSpans: array expected";
+ for (var i = 0; i < message.resourceSpans.length; ++i) {
+ var error = $root.opentelemetry.proto.trace.v1.ResourceSpans.verify(message.resourceSpans[i]);
+ if (error) return "resourceSpans." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportTraceServiceRequest message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} ExportTraceServiceRequest
+ */
+ ExportTraceServiceRequest.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest) return object;
+ var message = new $root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest();
+ if (object.resourceSpans) {
+ if (!Array.isArray(object.resourceSpans)) throw TypeError(".opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.resourceSpans: array expected");
+ message.resourceSpans = [];
+ for (var i = 0; i < object.resourceSpans.length; ++i) {
+ if (typeof object.resourceSpans[i] !== "object") throw TypeError(".opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.resourceSpans: object expected");
+ message.resourceSpans[i] = $root.opentelemetry.proto.trace.v1.ResourceSpans.fromObject(object.resourceSpans[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportTraceServiceRequest message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest} message ExportTraceServiceRequest
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportTraceServiceRequest.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.resourceSpans = [];
+ if (message.resourceSpans && message.resourceSpans.length) {
+ object.resourceSpans = [];
+ for (var j = 0; j < message.resourceSpans.length; ++j) object.resourceSpans[j] = $root.opentelemetry.proto.trace.v1.ResourceSpans.toObject(message.resourceSpans[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this ExportTraceServiceRequest to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportTraceServiceRequest.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportTraceServiceRequest
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportTraceServiceRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest";
+ };
+ return ExportTraceServiceRequest;
+ })();
+ v1.ExportTraceServiceResponse = (function() {
+ /**
+ * Properties of an ExportTraceServiceResponse.
+ * @memberof opentelemetry.proto.collector.trace.v1
+ * @interface IExportTraceServiceResponse
+ * @property {opentelemetry.proto.collector.trace.v1.IExportTracePartialSuccess|null} [partialSuccess] ExportTraceServiceResponse partialSuccess
+ */
+ /**
+ * Constructs a new ExportTraceServiceResponse.
+ * @memberof opentelemetry.proto.collector.trace.v1
+ * @classdesc Represents an ExportTraceServiceResponse.
+ * @implements IExportTraceServiceResponse
+ * @constructor
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceResponse=} [properties] Properties to set
+ */
+ function ExportTraceServiceResponse(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportTraceServiceResponse partialSuccess.
+ * @member {opentelemetry.proto.collector.trace.v1.IExportTracePartialSuccess|null|undefined} partialSuccess
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @instance
+ */
+ ExportTraceServiceResponse.prototype.partialSuccess = null;
+ /**
+ * Creates a new ExportTraceServiceResponse instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceResponse=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} ExportTraceServiceResponse instance
+ */
+ ExportTraceServiceResponse.create = function create(properties) {
+ return new ExportTraceServiceResponse(properties);
+ };
+ /**
+ * Encodes the specified ExportTraceServiceResponse message. Does not implicitly {@link opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceResponse} message ExportTraceServiceResponse message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportTraceServiceResponse.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.partialSuccess != null && Object.hasOwnProperty.call(message, "partialSuccess")) $root.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess.encode(message.partialSuccess, writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportTraceServiceResponse message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTraceServiceResponse} message ExportTraceServiceResponse message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportTraceServiceResponse.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportTraceServiceResponse message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} ExportTraceServiceResponse
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportTraceServiceResponse.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.partialSuccess = $root.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess.decode(reader, reader.uint32());
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportTraceServiceResponse message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} ExportTraceServiceResponse
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportTraceServiceResponse.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportTraceServiceResponse message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportTraceServiceResponse.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.partialSuccess != null && message.hasOwnProperty("partialSuccess")) {
+ var error = $root.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess.verify(message.partialSuccess);
+ if (error) return "partialSuccess." + error;
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportTraceServiceResponse message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} ExportTraceServiceResponse
+ */
+ ExportTraceServiceResponse.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse) return object;
+ var message = new $root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse();
+ if (object.partialSuccess != null) {
+ if (typeof object.partialSuccess !== "object") throw TypeError(".opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse.partialSuccess: object expected");
+ message.partialSuccess = $root.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess.fromObject(object.partialSuccess);
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportTraceServiceResponse message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse} message ExportTraceServiceResponse
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportTraceServiceResponse.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.defaults) object.partialSuccess = null;
+ if (message.partialSuccess != null && message.hasOwnProperty("partialSuccess")) object.partialSuccess = $root.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess.toObject(message.partialSuccess, options);
+ return object;
+ };
+ /**
+ * Converts this ExportTraceServiceResponse to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportTraceServiceResponse.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportTraceServiceResponse
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportTraceServiceResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse";
+ };
+ return ExportTraceServiceResponse;
+ })();
+ v1.ExportTracePartialSuccess = (function() {
+ /**
+ * Properties of an ExportTracePartialSuccess.
+ * @memberof opentelemetry.proto.collector.trace.v1
+ * @interface IExportTracePartialSuccess
+ * @property {number|Long|null} [rejectedSpans] ExportTracePartialSuccess rejectedSpans
+ * @property {string|null} [errorMessage] ExportTracePartialSuccess errorMessage
+ */
+ /**
+ * Constructs a new ExportTracePartialSuccess.
+ * @memberof opentelemetry.proto.collector.trace.v1
+ * @classdesc Represents an ExportTracePartialSuccess.
+ * @implements IExportTracePartialSuccess
+ * @constructor
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTracePartialSuccess=} [properties] Properties to set
+ */
+ function ExportTracePartialSuccess(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportTracePartialSuccess rejectedSpans.
+ * @member {number|Long|null|undefined} rejectedSpans
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @instance
+ */
+ ExportTracePartialSuccess.prototype.rejectedSpans = null;
+ /**
+ * ExportTracePartialSuccess errorMessage.
+ * @member {string|null|undefined} errorMessage
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @instance
+ */
+ ExportTracePartialSuccess.prototype.errorMessage = null;
+ /**
+ * Creates a new ExportTracePartialSuccess instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTracePartialSuccess=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess} ExportTracePartialSuccess instance
+ */
+ ExportTracePartialSuccess.create = function create(properties) {
+ return new ExportTracePartialSuccess(properties);
+ };
+ /**
+ * Encodes the specified ExportTracePartialSuccess message. Does not implicitly {@link opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTracePartialSuccess} message ExportTracePartialSuccess message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportTracePartialSuccess.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.rejectedSpans != null && Object.hasOwnProperty.call(message, "rejectedSpans")) writer.uint32(8).int64(message.rejectedSpans);
+ if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(18).string(message.errorMessage);
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportTracePartialSuccess message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.IExportTracePartialSuccess} message ExportTracePartialSuccess message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportTracePartialSuccess.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportTracePartialSuccess message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess} ExportTracePartialSuccess
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportTracePartialSuccess.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.rejectedSpans = reader.int64();
+ break;
+ case 2:
+ message.errorMessage = reader.string();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportTracePartialSuccess message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess} ExportTracePartialSuccess
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportTracePartialSuccess.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportTracePartialSuccess message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportTracePartialSuccess.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.rejectedSpans != null && message.hasOwnProperty("rejectedSpans")) {
+ if (!$util.isInteger(message.rejectedSpans) && !(message.rejectedSpans && $util.isInteger(message.rejectedSpans.low) && $util.isInteger(message.rejectedSpans.high))) return "rejectedSpans: integer|Long expected";
+ }
+ if (message.errorMessage != null && message.hasOwnProperty("errorMessage")) {
+ if (!$util.isString(message.errorMessage)) return "errorMessage: string expected";
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportTracePartialSuccess message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess} ExportTracePartialSuccess
+ */
+ ExportTracePartialSuccess.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess) return object;
+ var message = new $root.opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess();
+ if (object.rejectedSpans != null) {
+ if ($util.Long) (message.rejectedSpans = $util.Long.fromValue(object.rejectedSpans)).unsigned = false;
+ else if (typeof object.rejectedSpans === "string") message.rejectedSpans = parseInt(object.rejectedSpans, 10);
+ else if (typeof object.rejectedSpans === "number") message.rejectedSpans = object.rejectedSpans;
+ else if (typeof object.rejectedSpans === "object") message.rejectedSpans = new $util.LongBits(object.rejectedSpans.low >>> 0, object.rejectedSpans.high >>> 0).toNumber();
+ }
+ if (object.errorMessage != null) message.errorMessage = String(object.errorMessage);
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportTracePartialSuccess message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess} message ExportTracePartialSuccess
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportTracePartialSuccess.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.defaults) {
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.rejectedSpans = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.rejectedSpans = options.longs === String ? "0" : 0;
+ object.errorMessage = "";
+ }
+ if (message.rejectedSpans != null && message.hasOwnProperty("rejectedSpans")) if (typeof message.rejectedSpans === "number") object.rejectedSpans = options.longs === String ? String(message.rejectedSpans) : message.rejectedSpans;
+ else object.rejectedSpans = options.longs === String ? $util.Long.prototype.toString.call(message.rejectedSpans) : options.longs === Number ? new $util.LongBits(message.rejectedSpans.low >>> 0, message.rejectedSpans.high >>> 0).toNumber() : message.rejectedSpans;
+ if (message.errorMessage != null && message.hasOwnProperty("errorMessage")) object.errorMessage = message.errorMessage;
+ return object;
+ };
+ /**
+ * Converts this ExportTracePartialSuccess to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportTracePartialSuccess.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportTracePartialSuccess
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportTracePartialSuccess.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.trace.v1.ExportTracePartialSuccess";
+ };
+ return ExportTracePartialSuccess;
+ })();
+ return v1;
+ })();
+ return trace$1;
+ })();
+ collector.metrics = (function() {
+ /**
+ * Namespace metrics.
+ * @memberof opentelemetry.proto.collector
+ * @namespace
+ */
+ var metrics$1 = {};
+ metrics$1.v1 = (function() {
+ /**
+ * Namespace v1.
+ * @memberof opentelemetry.proto.collector.metrics
+ * @namespace
+ */
+ var v1 = {};
+ v1.MetricsService = (function() {
+ /**
+ * Constructs a new MetricsService service.
+ * @memberof opentelemetry.proto.collector.metrics.v1
+ * @classdesc Represents a MetricsService
+ * @extends $protobuf.rpc.Service
+ * @constructor
+ * @param {$protobuf.RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ */
+ function MetricsService(rpcImpl, requestDelimited, responseDelimited) {
+ $protobuf.rpc.Service.call(this, rpcImpl, requestDelimited, responseDelimited);
+ }
+ (MetricsService.prototype = Object.create($protobuf.rpc.Service.prototype)).constructor = MetricsService;
+ /**
+ * Creates new MetricsService service using the specified rpc implementation.
+ * @function create
+ * @memberof opentelemetry.proto.collector.metrics.v1.MetricsService
+ * @static
+ * @param {$protobuf.RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ * @returns {MetricsService} RPC service. Useful where requests and/or responses are streamed.
+ */
+ MetricsService.create = function create(rpcImpl, requestDelimited, responseDelimited) {
+ return new this(rpcImpl, requestDelimited, responseDelimited);
+ };
+ /**
+ * Callback as used by {@link opentelemetry.proto.collector.metrics.v1.MetricsService#export_}.
+ * @memberof opentelemetry.proto.collector.metrics.v1.MetricsService
+ * @typedef ExportCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse} [response] ExportMetricsServiceResponse
+ */
+ /**
+ * Calls Export.
+ * @function export
+ * @memberof opentelemetry.proto.collector.metrics.v1.MetricsService
+ * @instance
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceRequest} request ExportMetricsServiceRequest message or plain object
+ * @param {opentelemetry.proto.collector.metrics.v1.MetricsService.ExportCallback} callback Node-style callback called with the error, if any, and ExportMetricsServiceResponse
+ * @returns {undefined}
+ * @variation 1
+ */
+ Object.defineProperty(MetricsService.prototype["export"] = function export_(request, callback) {
+ return this.rpcCall(export_, $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest, $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse, request, callback);
+ }, "name", { value: "Export" });
+ /**
+ * Calls Export.
+ * @function export
+ * @memberof opentelemetry.proto.collector.metrics.v1.MetricsService
+ * @instance
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceRequest} request ExportMetricsServiceRequest message or plain object
+ * @returns {Promise} Promise
+ * @variation 2
+ */
+ return MetricsService;
+ })();
+ v1.ExportMetricsServiceRequest = (function() {
+ /**
+ * Properties of an ExportMetricsServiceRequest.
+ * @memberof opentelemetry.proto.collector.metrics.v1
+ * @interface IExportMetricsServiceRequest
+ * @property {Array.|null} [resourceMetrics] ExportMetricsServiceRequest resourceMetrics
+ */
+ /**
+ * Constructs a new ExportMetricsServiceRequest.
+ * @memberof opentelemetry.proto.collector.metrics.v1
+ * @classdesc Represents an ExportMetricsServiceRequest.
+ * @implements IExportMetricsServiceRequest
+ * @constructor
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceRequest=} [properties] Properties to set
+ */
+ function ExportMetricsServiceRequest(properties) {
+ this.resourceMetrics = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportMetricsServiceRequest resourceMetrics.
+ * @member {Array.} resourceMetrics
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @instance
+ */
+ ExportMetricsServiceRequest.prototype.resourceMetrics = $util.emptyArray;
+ /**
+ * Creates a new ExportMetricsServiceRequest instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceRequest=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest} ExportMetricsServiceRequest instance
+ */
+ ExportMetricsServiceRequest.create = function create(properties) {
+ return new ExportMetricsServiceRequest(properties);
+ };
+ /**
+ * Encodes the specified ExportMetricsServiceRequest message. Does not implicitly {@link opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceRequest} message ExportMetricsServiceRequest message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportMetricsServiceRequest.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.resourceMetrics != null && message.resourceMetrics.length) for (var i = 0; i < message.resourceMetrics.length; ++i) $root.opentelemetry.proto.metrics.v1.ResourceMetrics.encode(message.resourceMetrics[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportMetricsServiceRequest message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceRequest} message ExportMetricsServiceRequest message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportMetricsServiceRequest.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportMetricsServiceRequest message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest} ExportMetricsServiceRequest
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportMetricsServiceRequest.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.resourceMetrics && message.resourceMetrics.length)) message.resourceMetrics = [];
+ message.resourceMetrics.push($root.opentelemetry.proto.metrics.v1.ResourceMetrics.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportMetricsServiceRequest message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest} ExportMetricsServiceRequest
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportMetricsServiceRequest.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportMetricsServiceRequest message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportMetricsServiceRequest.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.resourceMetrics != null && message.hasOwnProperty("resourceMetrics")) {
+ if (!Array.isArray(message.resourceMetrics)) return "resourceMetrics: array expected";
+ for (var i = 0; i < message.resourceMetrics.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.ResourceMetrics.verify(message.resourceMetrics[i]);
+ if (error) return "resourceMetrics." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportMetricsServiceRequest message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest} ExportMetricsServiceRequest
+ */
+ ExportMetricsServiceRequest.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest) return object;
+ var message = new $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest();
+ if (object.resourceMetrics) {
+ if (!Array.isArray(object.resourceMetrics)) throw TypeError(".opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest.resourceMetrics: array expected");
+ message.resourceMetrics = [];
+ for (var i = 0; i < object.resourceMetrics.length; ++i) {
+ if (typeof object.resourceMetrics[i] !== "object") throw TypeError(".opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest.resourceMetrics: object expected");
+ message.resourceMetrics[i] = $root.opentelemetry.proto.metrics.v1.ResourceMetrics.fromObject(object.resourceMetrics[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportMetricsServiceRequest message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest} message ExportMetricsServiceRequest
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportMetricsServiceRequest.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.resourceMetrics = [];
+ if (message.resourceMetrics && message.resourceMetrics.length) {
+ object.resourceMetrics = [];
+ for (var j = 0; j < message.resourceMetrics.length; ++j) object.resourceMetrics[j] = $root.opentelemetry.proto.metrics.v1.ResourceMetrics.toObject(message.resourceMetrics[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this ExportMetricsServiceRequest to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportMetricsServiceRequest.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportMetricsServiceRequest
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportMetricsServiceRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest";
+ };
+ return ExportMetricsServiceRequest;
+ })();
+ v1.ExportMetricsServiceResponse = (function() {
+ /**
+ * Properties of an ExportMetricsServiceResponse.
+ * @memberof opentelemetry.proto.collector.metrics.v1
+ * @interface IExportMetricsServiceResponse
+ * @property {opentelemetry.proto.collector.metrics.v1.IExportMetricsPartialSuccess|null} [partialSuccess] ExportMetricsServiceResponse partialSuccess
+ */
+ /**
+ * Constructs a new ExportMetricsServiceResponse.
+ * @memberof opentelemetry.proto.collector.metrics.v1
+ * @classdesc Represents an ExportMetricsServiceResponse.
+ * @implements IExportMetricsServiceResponse
+ * @constructor
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceResponse=} [properties] Properties to set
+ */
+ function ExportMetricsServiceResponse(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportMetricsServiceResponse partialSuccess.
+ * @member {opentelemetry.proto.collector.metrics.v1.IExportMetricsPartialSuccess|null|undefined} partialSuccess
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @instance
+ */
+ ExportMetricsServiceResponse.prototype.partialSuccess = null;
+ /**
+ * Creates a new ExportMetricsServiceResponse instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceResponse=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse} ExportMetricsServiceResponse instance
+ */
+ ExportMetricsServiceResponse.create = function create(properties) {
+ return new ExportMetricsServiceResponse(properties);
+ };
+ /**
+ * Encodes the specified ExportMetricsServiceResponse message. Does not implicitly {@link opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceResponse} message ExportMetricsServiceResponse message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportMetricsServiceResponse.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.partialSuccess != null && Object.hasOwnProperty.call(message, "partialSuccess")) $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess.encode(message.partialSuccess, writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportMetricsServiceResponse message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsServiceResponse} message ExportMetricsServiceResponse message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportMetricsServiceResponse.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportMetricsServiceResponse message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse} ExportMetricsServiceResponse
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportMetricsServiceResponse.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.partialSuccess = $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess.decode(reader, reader.uint32());
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportMetricsServiceResponse message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse} ExportMetricsServiceResponse
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportMetricsServiceResponse.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportMetricsServiceResponse message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportMetricsServiceResponse.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.partialSuccess != null && message.hasOwnProperty("partialSuccess")) {
+ var error = $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess.verify(message.partialSuccess);
+ if (error) return "partialSuccess." + error;
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportMetricsServiceResponse message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse} ExportMetricsServiceResponse
+ */
+ ExportMetricsServiceResponse.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse) return object;
+ var message = new $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse();
+ if (object.partialSuccess != null) {
+ if (typeof object.partialSuccess !== "object") throw TypeError(".opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse.partialSuccess: object expected");
+ message.partialSuccess = $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess.fromObject(object.partialSuccess);
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportMetricsServiceResponse message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse} message ExportMetricsServiceResponse
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportMetricsServiceResponse.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.defaults) object.partialSuccess = null;
+ if (message.partialSuccess != null && message.hasOwnProperty("partialSuccess")) object.partialSuccess = $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess.toObject(message.partialSuccess, options);
+ return object;
+ };
+ /**
+ * Converts this ExportMetricsServiceResponse to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportMetricsServiceResponse.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportMetricsServiceResponse
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportMetricsServiceResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse";
+ };
+ return ExportMetricsServiceResponse;
+ })();
+ v1.ExportMetricsPartialSuccess = (function() {
+ /**
+ * Properties of an ExportMetricsPartialSuccess.
+ * @memberof opentelemetry.proto.collector.metrics.v1
+ * @interface IExportMetricsPartialSuccess
+ * @property {number|Long|null} [rejectedDataPoints] ExportMetricsPartialSuccess rejectedDataPoints
+ * @property {string|null} [errorMessage] ExportMetricsPartialSuccess errorMessage
+ */
+ /**
+ * Constructs a new ExportMetricsPartialSuccess.
+ * @memberof opentelemetry.proto.collector.metrics.v1
+ * @classdesc Represents an ExportMetricsPartialSuccess.
+ * @implements IExportMetricsPartialSuccess
+ * @constructor
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsPartialSuccess=} [properties] Properties to set
+ */
+ function ExportMetricsPartialSuccess(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportMetricsPartialSuccess rejectedDataPoints.
+ * @member {number|Long|null|undefined} rejectedDataPoints
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @instance
+ */
+ ExportMetricsPartialSuccess.prototype.rejectedDataPoints = null;
+ /**
+ * ExportMetricsPartialSuccess errorMessage.
+ * @member {string|null|undefined} errorMessage
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @instance
+ */
+ ExportMetricsPartialSuccess.prototype.errorMessage = null;
+ /**
+ * Creates a new ExportMetricsPartialSuccess instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsPartialSuccess=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess} ExportMetricsPartialSuccess instance
+ */
+ ExportMetricsPartialSuccess.create = function create(properties) {
+ return new ExportMetricsPartialSuccess(properties);
+ };
+ /**
+ * Encodes the specified ExportMetricsPartialSuccess message. Does not implicitly {@link opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsPartialSuccess} message ExportMetricsPartialSuccess message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportMetricsPartialSuccess.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.rejectedDataPoints != null && Object.hasOwnProperty.call(message, "rejectedDataPoints")) writer.uint32(8).int64(message.rejectedDataPoints);
+ if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(18).string(message.errorMessage);
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportMetricsPartialSuccess message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.IExportMetricsPartialSuccess} message ExportMetricsPartialSuccess message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportMetricsPartialSuccess.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportMetricsPartialSuccess message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess} ExportMetricsPartialSuccess
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportMetricsPartialSuccess.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.rejectedDataPoints = reader.int64();
+ break;
+ case 2:
+ message.errorMessage = reader.string();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportMetricsPartialSuccess message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess} ExportMetricsPartialSuccess
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportMetricsPartialSuccess.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportMetricsPartialSuccess message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportMetricsPartialSuccess.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.rejectedDataPoints != null && message.hasOwnProperty("rejectedDataPoints")) {
+ if (!$util.isInteger(message.rejectedDataPoints) && !(message.rejectedDataPoints && $util.isInteger(message.rejectedDataPoints.low) && $util.isInteger(message.rejectedDataPoints.high))) return "rejectedDataPoints: integer|Long expected";
+ }
+ if (message.errorMessage != null && message.hasOwnProperty("errorMessage")) {
+ if (!$util.isString(message.errorMessage)) return "errorMessage: string expected";
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportMetricsPartialSuccess message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess} ExportMetricsPartialSuccess
+ */
+ ExportMetricsPartialSuccess.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess) return object;
+ var message = new $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess();
+ if (object.rejectedDataPoints != null) {
+ if ($util.Long) (message.rejectedDataPoints = $util.Long.fromValue(object.rejectedDataPoints)).unsigned = false;
+ else if (typeof object.rejectedDataPoints === "string") message.rejectedDataPoints = parseInt(object.rejectedDataPoints, 10);
+ else if (typeof object.rejectedDataPoints === "number") message.rejectedDataPoints = object.rejectedDataPoints;
+ else if (typeof object.rejectedDataPoints === "object") message.rejectedDataPoints = new $util.LongBits(object.rejectedDataPoints.low >>> 0, object.rejectedDataPoints.high >>> 0).toNumber();
+ }
+ if (object.errorMessage != null) message.errorMessage = String(object.errorMessage);
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportMetricsPartialSuccess message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess} message ExportMetricsPartialSuccess
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportMetricsPartialSuccess.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.defaults) {
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.rejectedDataPoints = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.rejectedDataPoints = options.longs === String ? "0" : 0;
+ object.errorMessage = "";
+ }
+ if (message.rejectedDataPoints != null && message.hasOwnProperty("rejectedDataPoints")) if (typeof message.rejectedDataPoints === "number") object.rejectedDataPoints = options.longs === String ? String(message.rejectedDataPoints) : message.rejectedDataPoints;
+ else object.rejectedDataPoints = options.longs === String ? $util.Long.prototype.toString.call(message.rejectedDataPoints) : options.longs === Number ? new $util.LongBits(message.rejectedDataPoints.low >>> 0, message.rejectedDataPoints.high >>> 0).toNumber() : message.rejectedDataPoints;
+ if (message.errorMessage != null && message.hasOwnProperty("errorMessage")) object.errorMessage = message.errorMessage;
+ return object;
+ };
+ /**
+ * Converts this ExportMetricsPartialSuccess to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportMetricsPartialSuccess.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportMetricsPartialSuccess
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportMetricsPartialSuccess.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.metrics.v1.ExportMetricsPartialSuccess";
+ };
+ return ExportMetricsPartialSuccess;
+ })();
+ return v1;
+ })();
+ return metrics$1;
+ })();
+ collector.logs = (function() {
+ /**
+ * Namespace logs.
+ * @memberof opentelemetry.proto.collector
+ * @namespace
+ */
+ var logs = {};
+ logs.v1 = (function() {
+ /**
+ * Namespace v1.
+ * @memberof opentelemetry.proto.collector.logs
+ * @namespace
+ */
+ var v1 = {};
+ v1.LogsService = (function() {
+ /**
+ * Constructs a new LogsService service.
+ * @memberof opentelemetry.proto.collector.logs.v1
+ * @classdesc Represents a LogsService
+ * @extends $protobuf.rpc.Service
+ * @constructor
+ * @param {$protobuf.RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ */
+ function LogsService(rpcImpl, requestDelimited, responseDelimited) {
+ $protobuf.rpc.Service.call(this, rpcImpl, requestDelimited, responseDelimited);
+ }
+ (LogsService.prototype = Object.create($protobuf.rpc.Service.prototype)).constructor = LogsService;
+ /**
+ * Creates new LogsService service using the specified rpc implementation.
+ * @function create
+ * @memberof opentelemetry.proto.collector.logs.v1.LogsService
+ * @static
+ * @param {$protobuf.RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ * @returns {LogsService} RPC service. Useful where requests and/or responses are streamed.
+ */
+ LogsService.create = function create(rpcImpl, requestDelimited, responseDelimited) {
+ return new this(rpcImpl, requestDelimited, responseDelimited);
+ };
+ /**
+ * Callback as used by {@link opentelemetry.proto.collector.logs.v1.LogsService#export_}.
+ * @memberof opentelemetry.proto.collector.logs.v1.LogsService
+ * @typedef ExportCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse} [response] ExportLogsServiceResponse
+ */
+ /**
+ * Calls Export.
+ * @function export
+ * @memberof opentelemetry.proto.collector.logs.v1.LogsService
+ * @instance
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceRequest} request ExportLogsServiceRequest message or plain object
+ * @param {opentelemetry.proto.collector.logs.v1.LogsService.ExportCallback} callback Node-style callback called with the error, if any, and ExportLogsServiceResponse
+ * @returns {undefined}
+ * @variation 1
+ */
+ Object.defineProperty(LogsService.prototype["export"] = function export_(request, callback) {
+ return this.rpcCall(export_, $root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest, $root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse, request, callback);
+ }, "name", { value: "Export" });
+ /**
+ * Calls Export.
+ * @function export
+ * @memberof opentelemetry.proto.collector.logs.v1.LogsService
+ * @instance
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceRequest} request ExportLogsServiceRequest message or plain object
+ * @returns {Promise} Promise
+ * @variation 2
+ */
+ return LogsService;
+ })();
+ v1.ExportLogsServiceRequest = (function() {
+ /**
+ * Properties of an ExportLogsServiceRequest.
+ * @memberof opentelemetry.proto.collector.logs.v1
+ * @interface IExportLogsServiceRequest
+ * @property {Array.|null} [resourceLogs] ExportLogsServiceRequest resourceLogs
+ */
+ /**
+ * Constructs a new ExportLogsServiceRequest.
+ * @memberof opentelemetry.proto.collector.logs.v1
+ * @classdesc Represents an ExportLogsServiceRequest.
+ * @implements IExportLogsServiceRequest
+ * @constructor
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceRequest=} [properties] Properties to set
+ */
+ function ExportLogsServiceRequest(properties) {
+ this.resourceLogs = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportLogsServiceRequest resourceLogs.
+ * @member {Array.} resourceLogs
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @instance
+ */
+ ExportLogsServiceRequest.prototype.resourceLogs = $util.emptyArray;
+ /**
+ * Creates a new ExportLogsServiceRequest instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceRequest=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest} ExportLogsServiceRequest instance
+ */
+ ExportLogsServiceRequest.create = function create(properties) {
+ return new ExportLogsServiceRequest(properties);
+ };
+ /**
+ * Encodes the specified ExportLogsServiceRequest message. Does not implicitly {@link opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceRequest} message ExportLogsServiceRequest message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportLogsServiceRequest.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.resourceLogs != null && message.resourceLogs.length) for (var i = 0; i < message.resourceLogs.length; ++i) $root.opentelemetry.proto.logs.v1.ResourceLogs.encode(message.resourceLogs[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportLogsServiceRequest message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceRequest} message ExportLogsServiceRequest message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportLogsServiceRequest.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportLogsServiceRequest message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest} ExportLogsServiceRequest
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportLogsServiceRequest.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.resourceLogs && message.resourceLogs.length)) message.resourceLogs = [];
+ message.resourceLogs.push($root.opentelemetry.proto.logs.v1.ResourceLogs.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportLogsServiceRequest message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest} ExportLogsServiceRequest
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportLogsServiceRequest.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportLogsServiceRequest message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportLogsServiceRequest.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.resourceLogs != null && message.hasOwnProperty("resourceLogs")) {
+ if (!Array.isArray(message.resourceLogs)) return "resourceLogs: array expected";
+ for (var i = 0; i < message.resourceLogs.length; ++i) {
+ var error = $root.opentelemetry.proto.logs.v1.ResourceLogs.verify(message.resourceLogs[i]);
+ if (error) return "resourceLogs." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportLogsServiceRequest message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest} ExportLogsServiceRequest
+ */
+ ExportLogsServiceRequest.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest) return object;
+ var message = new $root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest();
+ if (object.resourceLogs) {
+ if (!Array.isArray(object.resourceLogs)) throw TypeError(".opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest.resourceLogs: array expected");
+ message.resourceLogs = [];
+ for (var i = 0; i < object.resourceLogs.length; ++i) {
+ if (typeof object.resourceLogs[i] !== "object") throw TypeError(".opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest.resourceLogs: object expected");
+ message.resourceLogs[i] = $root.opentelemetry.proto.logs.v1.ResourceLogs.fromObject(object.resourceLogs[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportLogsServiceRequest message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest} message ExportLogsServiceRequest
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportLogsServiceRequest.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.resourceLogs = [];
+ if (message.resourceLogs && message.resourceLogs.length) {
+ object.resourceLogs = [];
+ for (var j = 0; j < message.resourceLogs.length; ++j) object.resourceLogs[j] = $root.opentelemetry.proto.logs.v1.ResourceLogs.toObject(message.resourceLogs[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this ExportLogsServiceRequest to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportLogsServiceRequest.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportLogsServiceRequest
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportLogsServiceRequest.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest";
+ };
+ return ExportLogsServiceRequest;
+ })();
+ v1.ExportLogsServiceResponse = (function() {
+ /**
+ * Properties of an ExportLogsServiceResponse.
+ * @memberof opentelemetry.proto.collector.logs.v1
+ * @interface IExportLogsServiceResponse
+ * @property {opentelemetry.proto.collector.logs.v1.IExportLogsPartialSuccess|null} [partialSuccess] ExportLogsServiceResponse partialSuccess
+ */
+ /**
+ * Constructs a new ExportLogsServiceResponse.
+ * @memberof opentelemetry.proto.collector.logs.v1
+ * @classdesc Represents an ExportLogsServiceResponse.
+ * @implements IExportLogsServiceResponse
+ * @constructor
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceResponse=} [properties] Properties to set
+ */
+ function ExportLogsServiceResponse(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportLogsServiceResponse partialSuccess.
+ * @member {opentelemetry.proto.collector.logs.v1.IExportLogsPartialSuccess|null|undefined} partialSuccess
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @instance
+ */
+ ExportLogsServiceResponse.prototype.partialSuccess = null;
+ /**
+ * Creates a new ExportLogsServiceResponse instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceResponse=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse} ExportLogsServiceResponse instance
+ */
+ ExportLogsServiceResponse.create = function create(properties) {
+ return new ExportLogsServiceResponse(properties);
+ };
+ /**
+ * Encodes the specified ExportLogsServiceResponse message. Does not implicitly {@link opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceResponse} message ExportLogsServiceResponse message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportLogsServiceResponse.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.partialSuccess != null && Object.hasOwnProperty.call(message, "partialSuccess")) $root.opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess.encode(message.partialSuccess, writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportLogsServiceResponse message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsServiceResponse} message ExportLogsServiceResponse message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportLogsServiceResponse.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportLogsServiceResponse message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse} ExportLogsServiceResponse
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportLogsServiceResponse.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.partialSuccess = $root.opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess.decode(reader, reader.uint32());
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportLogsServiceResponse message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse} ExportLogsServiceResponse
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportLogsServiceResponse.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportLogsServiceResponse message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportLogsServiceResponse.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.partialSuccess != null && message.hasOwnProperty("partialSuccess")) {
+ var error = $root.opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess.verify(message.partialSuccess);
+ if (error) return "partialSuccess." + error;
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportLogsServiceResponse message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse} ExportLogsServiceResponse
+ */
+ ExportLogsServiceResponse.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse) return object;
+ var message = new $root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse();
+ if (object.partialSuccess != null) {
+ if (typeof object.partialSuccess !== "object") throw TypeError(".opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse.partialSuccess: object expected");
+ message.partialSuccess = $root.opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess.fromObject(object.partialSuccess);
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportLogsServiceResponse message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse} message ExportLogsServiceResponse
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportLogsServiceResponse.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.defaults) object.partialSuccess = null;
+ if (message.partialSuccess != null && message.hasOwnProperty("partialSuccess")) object.partialSuccess = $root.opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess.toObject(message.partialSuccess, options);
+ return object;
+ };
+ /**
+ * Converts this ExportLogsServiceResponse to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportLogsServiceResponse.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportLogsServiceResponse
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportLogsServiceResponse.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse";
+ };
+ return ExportLogsServiceResponse;
+ })();
+ v1.ExportLogsPartialSuccess = (function() {
+ /**
+ * Properties of an ExportLogsPartialSuccess.
+ * @memberof opentelemetry.proto.collector.logs.v1
+ * @interface IExportLogsPartialSuccess
+ * @property {number|Long|null} [rejectedLogRecords] ExportLogsPartialSuccess rejectedLogRecords
+ * @property {string|null} [errorMessage] ExportLogsPartialSuccess errorMessage
+ */
+ /**
+ * Constructs a new ExportLogsPartialSuccess.
+ * @memberof opentelemetry.proto.collector.logs.v1
+ * @classdesc Represents an ExportLogsPartialSuccess.
+ * @implements IExportLogsPartialSuccess
+ * @constructor
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsPartialSuccess=} [properties] Properties to set
+ */
+ function ExportLogsPartialSuccess(properties) {
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExportLogsPartialSuccess rejectedLogRecords.
+ * @member {number|Long|null|undefined} rejectedLogRecords
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @instance
+ */
+ ExportLogsPartialSuccess.prototype.rejectedLogRecords = null;
+ /**
+ * ExportLogsPartialSuccess errorMessage.
+ * @member {string|null|undefined} errorMessage
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @instance
+ */
+ ExportLogsPartialSuccess.prototype.errorMessage = null;
+ /**
+ * Creates a new ExportLogsPartialSuccess instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsPartialSuccess=} [properties] Properties to set
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess} ExportLogsPartialSuccess instance
+ */
+ ExportLogsPartialSuccess.create = function create(properties) {
+ return new ExportLogsPartialSuccess(properties);
+ };
+ /**
+ * Encodes the specified ExportLogsPartialSuccess message. Does not implicitly {@link opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsPartialSuccess} message ExportLogsPartialSuccess message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportLogsPartialSuccess.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.rejectedLogRecords != null && Object.hasOwnProperty.call(message, "rejectedLogRecords")) writer.uint32(8).int64(message.rejectedLogRecords);
+ if (message.errorMessage != null && Object.hasOwnProperty.call(message, "errorMessage")) writer.uint32(18).string(message.errorMessage);
+ return writer;
+ };
+ /**
+ * Encodes the specified ExportLogsPartialSuccess message, length delimited. Does not implicitly {@link opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.IExportLogsPartialSuccess} message ExportLogsPartialSuccess message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExportLogsPartialSuccess.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExportLogsPartialSuccess message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess} ExportLogsPartialSuccess
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportLogsPartialSuccess.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.rejectedLogRecords = reader.int64();
+ break;
+ case 2:
+ message.errorMessage = reader.string();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExportLogsPartialSuccess message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess} ExportLogsPartialSuccess
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExportLogsPartialSuccess.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExportLogsPartialSuccess message.
+ * @function verify
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExportLogsPartialSuccess.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.rejectedLogRecords != null && message.hasOwnProperty("rejectedLogRecords")) {
+ if (!$util.isInteger(message.rejectedLogRecords) && !(message.rejectedLogRecords && $util.isInteger(message.rejectedLogRecords.low) && $util.isInteger(message.rejectedLogRecords.high))) return "rejectedLogRecords: integer|Long expected";
+ }
+ if (message.errorMessage != null && message.hasOwnProperty("errorMessage")) {
+ if (!$util.isString(message.errorMessage)) return "errorMessage: string expected";
+ }
+ return null;
+ };
+ /**
+ * Creates an ExportLogsPartialSuccess message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess} ExportLogsPartialSuccess
+ */
+ ExportLogsPartialSuccess.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess) return object;
+ var message = new $root.opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess();
+ if (object.rejectedLogRecords != null) {
+ if ($util.Long) (message.rejectedLogRecords = $util.Long.fromValue(object.rejectedLogRecords)).unsigned = false;
+ else if (typeof object.rejectedLogRecords === "string") message.rejectedLogRecords = parseInt(object.rejectedLogRecords, 10);
+ else if (typeof object.rejectedLogRecords === "number") message.rejectedLogRecords = object.rejectedLogRecords;
+ else if (typeof object.rejectedLogRecords === "object") message.rejectedLogRecords = new $util.LongBits(object.rejectedLogRecords.low >>> 0, object.rejectedLogRecords.high >>> 0).toNumber();
+ }
+ if (object.errorMessage != null) message.errorMessage = String(object.errorMessage);
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExportLogsPartialSuccess message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess} message ExportLogsPartialSuccess
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExportLogsPartialSuccess.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.defaults) {
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.rejectedLogRecords = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.rejectedLogRecords = options.longs === String ? "0" : 0;
+ object.errorMessage = "";
+ }
+ if (message.rejectedLogRecords != null && message.hasOwnProperty("rejectedLogRecords")) if (typeof message.rejectedLogRecords === "number") object.rejectedLogRecords = options.longs === String ? String(message.rejectedLogRecords) : message.rejectedLogRecords;
+ else object.rejectedLogRecords = options.longs === String ? $util.Long.prototype.toString.call(message.rejectedLogRecords) : options.longs === Number ? new $util.LongBits(message.rejectedLogRecords.low >>> 0, message.rejectedLogRecords.high >>> 0).toNumber() : message.rejectedLogRecords;
+ if (message.errorMessage != null && message.hasOwnProperty("errorMessage")) object.errorMessage = message.errorMessage;
+ return object;
+ };
+ /**
+ * Converts this ExportLogsPartialSuccess to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExportLogsPartialSuccess.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExportLogsPartialSuccess
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExportLogsPartialSuccess.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.collector.logs.v1.ExportLogsPartialSuccess";
+ };
+ return ExportLogsPartialSuccess;
+ })();
+ return v1;
+ })();
+ return logs;
+ })();
+ return collector;
+ })();
+ proto.metrics = (function() {
+ /**
+ * Namespace metrics.
+ * @memberof opentelemetry.proto
+ * @namespace
+ */
+ var metrics$1 = {};
+ metrics$1.v1 = (function() {
+ /**
+ * Namespace v1.
+ * @memberof opentelemetry.proto.metrics
+ * @namespace
+ */
+ var v1 = {};
+ v1.MetricsData = (function() {
+ /**
+ * Properties of a MetricsData.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IMetricsData
+ * @property {Array.|null} [resourceMetrics] MetricsData resourceMetrics
+ */
+ /**
+ * Constructs a new MetricsData.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a MetricsData.
+ * @implements IMetricsData
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IMetricsData=} [properties] Properties to set
+ */
+ function MetricsData(properties) {
+ this.resourceMetrics = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * MetricsData resourceMetrics.
+ * @member {Array.} resourceMetrics
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @instance
+ */
+ MetricsData.prototype.resourceMetrics = $util.emptyArray;
+ /**
+ * Creates a new MetricsData instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IMetricsData=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.MetricsData} MetricsData instance
+ */
+ MetricsData.create = function create(properties) {
+ return new MetricsData(properties);
+ };
+ /**
+ * Encodes the specified MetricsData message. Does not implicitly {@link opentelemetry.proto.metrics.v1.MetricsData.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IMetricsData} message MetricsData message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ MetricsData.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.resourceMetrics != null && message.resourceMetrics.length) for (var i = 0; i < message.resourceMetrics.length; ++i) $root.opentelemetry.proto.metrics.v1.ResourceMetrics.encode(message.resourceMetrics[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified MetricsData message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.MetricsData.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IMetricsData} message MetricsData message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ MetricsData.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a MetricsData message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.MetricsData} MetricsData
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ MetricsData.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.MetricsData();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.resourceMetrics && message.resourceMetrics.length)) message.resourceMetrics = [];
+ message.resourceMetrics.push($root.opentelemetry.proto.metrics.v1.ResourceMetrics.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a MetricsData message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.MetricsData} MetricsData
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ MetricsData.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a MetricsData message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ MetricsData.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.resourceMetrics != null && message.hasOwnProperty("resourceMetrics")) {
+ if (!Array.isArray(message.resourceMetrics)) return "resourceMetrics: array expected";
+ for (var i = 0; i < message.resourceMetrics.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.ResourceMetrics.verify(message.resourceMetrics[i]);
+ if (error) return "resourceMetrics." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates a MetricsData message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.MetricsData} MetricsData
+ */
+ MetricsData.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.MetricsData) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.MetricsData();
+ if (object.resourceMetrics) {
+ if (!Array.isArray(object.resourceMetrics)) throw TypeError(".opentelemetry.proto.metrics.v1.MetricsData.resourceMetrics: array expected");
+ message.resourceMetrics = [];
+ for (var i = 0; i < object.resourceMetrics.length; ++i) {
+ if (typeof object.resourceMetrics[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.MetricsData.resourceMetrics: object expected");
+ message.resourceMetrics[i] = $root.opentelemetry.proto.metrics.v1.ResourceMetrics.fromObject(object.resourceMetrics[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a MetricsData message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.MetricsData} message MetricsData
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ MetricsData.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.resourceMetrics = [];
+ if (message.resourceMetrics && message.resourceMetrics.length) {
+ object.resourceMetrics = [];
+ for (var j = 0; j < message.resourceMetrics.length; ++j) object.resourceMetrics[j] = $root.opentelemetry.proto.metrics.v1.ResourceMetrics.toObject(message.resourceMetrics[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this MetricsData to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ MetricsData.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for MetricsData
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.MetricsData
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ MetricsData.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.MetricsData";
+ };
+ return MetricsData;
+ })();
+ v1.ResourceMetrics = (function() {
+ /**
+ * Properties of a ResourceMetrics.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IResourceMetrics
+ * @property {opentelemetry.proto.resource.v1.IResource|null} [resource] ResourceMetrics resource
+ * @property {Array.|null} [scopeMetrics] ResourceMetrics scopeMetrics
+ * @property {string|null} [schemaUrl] ResourceMetrics schemaUrl
+ */
+ /**
+ * Constructs a new ResourceMetrics.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a ResourceMetrics.
+ * @implements IResourceMetrics
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IResourceMetrics=} [properties] Properties to set
+ */
+ function ResourceMetrics(properties) {
+ this.scopeMetrics = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ResourceMetrics resource.
+ * @member {opentelemetry.proto.resource.v1.IResource|null|undefined} resource
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @instance
+ */
+ ResourceMetrics.prototype.resource = null;
+ /**
+ * ResourceMetrics scopeMetrics.
+ * @member {Array.} scopeMetrics
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @instance
+ */
+ ResourceMetrics.prototype.scopeMetrics = $util.emptyArray;
+ /**
+ * ResourceMetrics schemaUrl.
+ * @member {string|null|undefined} schemaUrl
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @instance
+ */
+ ResourceMetrics.prototype.schemaUrl = null;
+ /**
+ * Creates a new ResourceMetrics instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IResourceMetrics=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.ResourceMetrics} ResourceMetrics instance
+ */
+ ResourceMetrics.create = function create(properties) {
+ return new ResourceMetrics(properties);
+ };
+ /**
+ * Encodes the specified ResourceMetrics message. Does not implicitly {@link opentelemetry.proto.metrics.v1.ResourceMetrics.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IResourceMetrics} message ResourceMetrics message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ResourceMetrics.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.resource != null && Object.hasOwnProperty.call(message, "resource")) $root.opentelemetry.proto.resource.v1.Resource.encode(message.resource, writer.uint32(10).fork()).ldelim();
+ if (message.scopeMetrics != null && message.scopeMetrics.length) for (var i = 0; i < message.scopeMetrics.length; ++i) $root.opentelemetry.proto.metrics.v1.ScopeMetrics.encode(message.scopeMetrics[i], writer.uint32(18).fork()).ldelim();
+ if (message.schemaUrl != null && Object.hasOwnProperty.call(message, "schemaUrl")) writer.uint32(26).string(message.schemaUrl);
+ return writer;
+ };
+ /**
+ * Encodes the specified ResourceMetrics message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.ResourceMetrics.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IResourceMetrics} message ResourceMetrics message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ResourceMetrics.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a ResourceMetrics message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.ResourceMetrics} ResourceMetrics
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ResourceMetrics.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.ResourceMetrics();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.resource = $root.opentelemetry.proto.resource.v1.Resource.decode(reader, reader.uint32());
+ break;
+ case 2:
+ if (!(message.scopeMetrics && message.scopeMetrics.length)) message.scopeMetrics = [];
+ message.scopeMetrics.push($root.opentelemetry.proto.metrics.v1.ScopeMetrics.decode(reader, reader.uint32()));
+ break;
+ case 3:
+ message.schemaUrl = reader.string();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a ResourceMetrics message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.ResourceMetrics} ResourceMetrics
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ResourceMetrics.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a ResourceMetrics message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ResourceMetrics.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.resource != null && message.hasOwnProperty("resource")) {
+ var error = $root.opentelemetry.proto.resource.v1.Resource.verify(message.resource);
+ if (error) return "resource." + error;
+ }
+ if (message.scopeMetrics != null && message.hasOwnProperty("scopeMetrics")) {
+ if (!Array.isArray(message.scopeMetrics)) return "scopeMetrics: array expected";
+ for (var i = 0; i < message.scopeMetrics.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.ScopeMetrics.verify(message.scopeMetrics[i]);
+ if (error) return "scopeMetrics." + error;
+ }
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) {
+ if (!$util.isString(message.schemaUrl)) return "schemaUrl: string expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a ResourceMetrics message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.ResourceMetrics} ResourceMetrics
+ */
+ ResourceMetrics.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.ResourceMetrics) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.ResourceMetrics();
+ if (object.resource != null) {
+ if (typeof object.resource !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ResourceMetrics.resource: object expected");
+ message.resource = $root.opentelemetry.proto.resource.v1.Resource.fromObject(object.resource);
+ }
+ if (object.scopeMetrics) {
+ if (!Array.isArray(object.scopeMetrics)) throw TypeError(".opentelemetry.proto.metrics.v1.ResourceMetrics.scopeMetrics: array expected");
+ message.scopeMetrics = [];
+ for (var i = 0; i < object.scopeMetrics.length; ++i) {
+ if (typeof object.scopeMetrics[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ResourceMetrics.scopeMetrics: object expected");
+ message.scopeMetrics[i] = $root.opentelemetry.proto.metrics.v1.ScopeMetrics.fromObject(object.scopeMetrics[i]);
+ }
+ }
+ if (object.schemaUrl != null) message.schemaUrl = String(object.schemaUrl);
+ return message;
+ };
+ /**
+ * Creates a plain object from a ResourceMetrics message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ResourceMetrics} message ResourceMetrics
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ResourceMetrics.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.scopeMetrics = [];
+ if (options.defaults) {
+ object.resource = null;
+ object.schemaUrl = "";
+ }
+ if (message.resource != null && message.hasOwnProperty("resource")) object.resource = $root.opentelemetry.proto.resource.v1.Resource.toObject(message.resource, options);
+ if (message.scopeMetrics && message.scopeMetrics.length) {
+ object.scopeMetrics = [];
+ for (var j = 0; j < message.scopeMetrics.length; ++j) object.scopeMetrics[j] = $root.opentelemetry.proto.metrics.v1.ScopeMetrics.toObject(message.scopeMetrics[j], options);
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) object.schemaUrl = message.schemaUrl;
+ return object;
+ };
+ /**
+ * Converts this ResourceMetrics to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ResourceMetrics.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ResourceMetrics
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.ResourceMetrics
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ResourceMetrics.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.ResourceMetrics";
+ };
+ return ResourceMetrics;
+ })();
+ v1.ScopeMetrics = (function() {
+ /**
+ * Properties of a ScopeMetrics.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IScopeMetrics
+ * @property {opentelemetry.proto.common.v1.IInstrumentationScope|null} [scope] ScopeMetrics scope
+ * @property {Array.|null} [metrics] ScopeMetrics metrics
+ * @property {string|null} [schemaUrl] ScopeMetrics schemaUrl
+ */
+ /**
+ * Constructs a new ScopeMetrics.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a ScopeMetrics.
+ * @implements IScopeMetrics
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IScopeMetrics=} [properties] Properties to set
+ */
+ function ScopeMetrics(properties) {
+ this.metrics = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ScopeMetrics scope.
+ * @member {opentelemetry.proto.common.v1.IInstrumentationScope|null|undefined} scope
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @instance
+ */
+ ScopeMetrics.prototype.scope = null;
+ /**
+ * ScopeMetrics metrics.
+ * @member {Array.} metrics
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @instance
+ */
+ ScopeMetrics.prototype.metrics = $util.emptyArray;
+ /**
+ * ScopeMetrics schemaUrl.
+ * @member {string|null|undefined} schemaUrl
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @instance
+ */
+ ScopeMetrics.prototype.schemaUrl = null;
+ /**
+ * Creates a new ScopeMetrics instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IScopeMetrics=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.ScopeMetrics} ScopeMetrics instance
+ */
+ ScopeMetrics.create = function create(properties) {
+ return new ScopeMetrics(properties);
+ };
+ /**
+ * Encodes the specified ScopeMetrics message. Does not implicitly {@link opentelemetry.proto.metrics.v1.ScopeMetrics.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IScopeMetrics} message ScopeMetrics message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ScopeMetrics.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.scope != null && Object.hasOwnProperty.call(message, "scope")) $root.opentelemetry.proto.common.v1.InstrumentationScope.encode(message.scope, writer.uint32(10).fork()).ldelim();
+ if (message.metrics != null && message.metrics.length) for (var i = 0; i < message.metrics.length; ++i) $root.opentelemetry.proto.metrics.v1.Metric.encode(message.metrics[i], writer.uint32(18).fork()).ldelim();
+ if (message.schemaUrl != null && Object.hasOwnProperty.call(message, "schemaUrl")) writer.uint32(26).string(message.schemaUrl);
+ return writer;
+ };
+ /**
+ * Encodes the specified ScopeMetrics message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.ScopeMetrics.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IScopeMetrics} message ScopeMetrics message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ScopeMetrics.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a ScopeMetrics message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.ScopeMetrics} ScopeMetrics
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ScopeMetrics.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.ScopeMetrics();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.scope = $root.opentelemetry.proto.common.v1.InstrumentationScope.decode(reader, reader.uint32());
+ break;
+ case 2:
+ if (!(message.metrics && message.metrics.length)) message.metrics = [];
+ message.metrics.push($root.opentelemetry.proto.metrics.v1.Metric.decode(reader, reader.uint32()));
+ break;
+ case 3:
+ message.schemaUrl = reader.string();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a ScopeMetrics message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.ScopeMetrics} ScopeMetrics
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ScopeMetrics.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a ScopeMetrics message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ScopeMetrics.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.scope != null && message.hasOwnProperty("scope")) {
+ var error = $root.opentelemetry.proto.common.v1.InstrumentationScope.verify(message.scope);
+ if (error) return "scope." + error;
+ }
+ if (message.metrics != null && message.hasOwnProperty("metrics")) {
+ if (!Array.isArray(message.metrics)) return "metrics: array expected";
+ for (var i = 0; i < message.metrics.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.Metric.verify(message.metrics[i]);
+ if (error) return "metrics." + error;
+ }
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) {
+ if (!$util.isString(message.schemaUrl)) return "schemaUrl: string expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a ScopeMetrics message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.ScopeMetrics} ScopeMetrics
+ */
+ ScopeMetrics.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.ScopeMetrics) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.ScopeMetrics();
+ if (object.scope != null) {
+ if (typeof object.scope !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ScopeMetrics.scope: object expected");
+ message.scope = $root.opentelemetry.proto.common.v1.InstrumentationScope.fromObject(object.scope);
+ }
+ if (object.metrics) {
+ if (!Array.isArray(object.metrics)) throw TypeError(".opentelemetry.proto.metrics.v1.ScopeMetrics.metrics: array expected");
+ message.metrics = [];
+ for (var i = 0; i < object.metrics.length; ++i) {
+ if (typeof object.metrics[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ScopeMetrics.metrics: object expected");
+ message.metrics[i] = $root.opentelemetry.proto.metrics.v1.Metric.fromObject(object.metrics[i]);
+ }
+ }
+ if (object.schemaUrl != null) message.schemaUrl = String(object.schemaUrl);
+ return message;
+ };
+ /**
+ * Creates a plain object from a ScopeMetrics message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ScopeMetrics} message ScopeMetrics
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ScopeMetrics.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.metrics = [];
+ if (options.defaults) {
+ object.scope = null;
+ object.schemaUrl = "";
+ }
+ if (message.scope != null && message.hasOwnProperty("scope")) object.scope = $root.opentelemetry.proto.common.v1.InstrumentationScope.toObject(message.scope, options);
+ if (message.metrics && message.metrics.length) {
+ object.metrics = [];
+ for (var j = 0; j < message.metrics.length; ++j) object.metrics[j] = $root.opentelemetry.proto.metrics.v1.Metric.toObject(message.metrics[j], options);
+ }
+ if (message.schemaUrl != null && message.hasOwnProperty("schemaUrl")) object.schemaUrl = message.schemaUrl;
+ return object;
+ };
+ /**
+ * Converts this ScopeMetrics to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ScopeMetrics.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ScopeMetrics
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.ScopeMetrics
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ScopeMetrics.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.ScopeMetrics";
+ };
+ return ScopeMetrics;
+ })();
+ v1.Metric = (function() {
+ /**
+ * Properties of a Metric.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IMetric
+ * @property {string|null} [name] Metric name
+ * @property {string|null} [description] Metric description
+ * @property {string|null} [unit] Metric unit
+ * @property {opentelemetry.proto.metrics.v1.IGauge|null} [gauge] Metric gauge
+ * @property {opentelemetry.proto.metrics.v1.ISum|null} [sum] Metric sum
+ * @property {opentelemetry.proto.metrics.v1.IHistogram|null} [histogram] Metric histogram
+ * @property {opentelemetry.proto.metrics.v1.IExponentialHistogram|null} [exponentialHistogram] Metric exponentialHistogram
+ * @property {opentelemetry.proto.metrics.v1.ISummary|null} [summary] Metric summary
+ * @property {Array.|null} [metadata] Metric metadata
+ */
+ /**
+ * Constructs a new Metric.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a Metric.
+ * @implements IMetric
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IMetric=} [properties] Properties to set
+ */
+ function Metric(properties) {
+ this.metadata = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Metric name.
+ * @member {string|null|undefined} name
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.name = null;
+ /**
+ * Metric description.
+ * @member {string|null|undefined} description
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.description = null;
+ /**
+ * Metric unit.
+ * @member {string|null|undefined} unit
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.unit = null;
+ /**
+ * Metric gauge.
+ * @member {opentelemetry.proto.metrics.v1.IGauge|null|undefined} gauge
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.gauge = null;
+ /**
+ * Metric sum.
+ * @member {opentelemetry.proto.metrics.v1.ISum|null|undefined} sum
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.sum = null;
+ /**
+ * Metric histogram.
+ * @member {opentelemetry.proto.metrics.v1.IHistogram|null|undefined} histogram
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.histogram = null;
+ /**
+ * Metric exponentialHistogram.
+ * @member {opentelemetry.proto.metrics.v1.IExponentialHistogram|null|undefined} exponentialHistogram
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.exponentialHistogram = null;
+ /**
+ * Metric summary.
+ * @member {opentelemetry.proto.metrics.v1.ISummary|null|undefined} summary
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.summary = null;
+ /**
+ * Metric metadata.
+ * @member {Array.} metadata
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Metric.prototype.metadata = $util.emptyArray;
+ var $oneOfFields;
+ /**
+ * Metric data.
+ * @member {"gauge"|"sum"|"histogram"|"exponentialHistogram"|"summary"|undefined} data
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ */
+ Object.defineProperty(Metric.prototype, "data", {
+ get: $util.oneOfGetter($oneOfFields = [
+ "gauge",
+ "sum",
+ "histogram",
+ "exponentialHistogram",
+ "summary"
+ ]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * Creates a new Metric instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IMetric=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.Metric} Metric instance
+ */
+ Metric.create = function create(properties) {
+ return new Metric(properties);
+ };
+ /**
+ * Encodes the specified Metric message. Does not implicitly {@link opentelemetry.proto.metrics.v1.Metric.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IMetric} message Metric message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Metric.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.name != null && Object.hasOwnProperty.call(message, "name")) writer.uint32(10).string(message.name);
+ if (message.description != null && Object.hasOwnProperty.call(message, "description")) writer.uint32(18).string(message.description);
+ if (message.unit != null && Object.hasOwnProperty.call(message, "unit")) writer.uint32(26).string(message.unit);
+ if (message.gauge != null && Object.hasOwnProperty.call(message, "gauge")) $root.opentelemetry.proto.metrics.v1.Gauge.encode(message.gauge, writer.uint32(42).fork()).ldelim();
+ if (message.sum != null && Object.hasOwnProperty.call(message, "sum")) $root.opentelemetry.proto.metrics.v1.Sum.encode(message.sum, writer.uint32(58).fork()).ldelim();
+ if (message.histogram != null && Object.hasOwnProperty.call(message, "histogram")) $root.opentelemetry.proto.metrics.v1.Histogram.encode(message.histogram, writer.uint32(74).fork()).ldelim();
+ if (message.exponentialHistogram != null && Object.hasOwnProperty.call(message, "exponentialHistogram")) $root.opentelemetry.proto.metrics.v1.ExponentialHistogram.encode(message.exponentialHistogram, writer.uint32(82).fork()).ldelim();
+ if (message.summary != null && Object.hasOwnProperty.call(message, "summary")) $root.opentelemetry.proto.metrics.v1.Summary.encode(message.summary, writer.uint32(90).fork()).ldelim();
+ if (message.metadata != null && message.metadata.length) for (var i = 0; i < message.metadata.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.metadata[i], writer.uint32(98).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified Metric message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.Metric.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IMetric} message Metric message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Metric.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Metric message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.Metric} Metric
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Metric.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.Metric();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.name = reader.string();
+ break;
+ case 2:
+ message.description = reader.string();
+ break;
+ case 3:
+ message.unit = reader.string();
+ break;
+ case 5:
+ message.gauge = $root.opentelemetry.proto.metrics.v1.Gauge.decode(reader, reader.uint32());
+ break;
+ case 7:
+ message.sum = $root.opentelemetry.proto.metrics.v1.Sum.decode(reader, reader.uint32());
+ break;
+ case 9:
+ message.histogram = $root.opentelemetry.proto.metrics.v1.Histogram.decode(reader, reader.uint32());
+ break;
+ case 10:
+ message.exponentialHistogram = $root.opentelemetry.proto.metrics.v1.ExponentialHistogram.decode(reader, reader.uint32());
+ break;
+ case 11:
+ message.summary = $root.opentelemetry.proto.metrics.v1.Summary.decode(reader, reader.uint32());
+ break;
+ case 12:
+ if (!(message.metadata && message.metadata.length)) message.metadata = [];
+ message.metadata.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Metric message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.Metric} Metric
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Metric.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Metric message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Metric.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ var properties = {};
+ if (message.name != null && message.hasOwnProperty("name")) {
+ if (!$util.isString(message.name)) return "name: string expected";
+ }
+ if (message.description != null && message.hasOwnProperty("description")) {
+ if (!$util.isString(message.description)) return "description: string expected";
+ }
+ if (message.unit != null && message.hasOwnProperty("unit")) {
+ if (!$util.isString(message.unit)) return "unit: string expected";
+ }
+ if (message.gauge != null && message.hasOwnProperty("gauge")) {
+ properties.data = 1;
+ var error = $root.opentelemetry.proto.metrics.v1.Gauge.verify(message.gauge);
+ if (error) return "gauge." + error;
+ }
+ if (message.sum != null && message.hasOwnProperty("sum")) {
+ if (properties.data === 1) return "data: multiple values";
+ properties.data = 1;
+ var error = $root.opentelemetry.proto.metrics.v1.Sum.verify(message.sum);
+ if (error) return "sum." + error;
+ }
+ if (message.histogram != null && message.hasOwnProperty("histogram")) {
+ if (properties.data === 1) return "data: multiple values";
+ properties.data = 1;
+ var error = $root.opentelemetry.proto.metrics.v1.Histogram.verify(message.histogram);
+ if (error) return "histogram." + error;
+ }
+ if (message.exponentialHistogram != null && message.hasOwnProperty("exponentialHistogram")) {
+ if (properties.data === 1) return "data: multiple values";
+ properties.data = 1;
+ var error = $root.opentelemetry.proto.metrics.v1.ExponentialHistogram.verify(message.exponentialHistogram);
+ if (error) return "exponentialHistogram." + error;
+ }
+ if (message.summary != null && message.hasOwnProperty("summary")) {
+ if (properties.data === 1) return "data: multiple values";
+ properties.data = 1;
+ var error = $root.opentelemetry.proto.metrics.v1.Summary.verify(message.summary);
+ if (error) return "summary." + error;
+ }
+ if (message.metadata != null && message.hasOwnProperty("metadata")) {
+ if (!Array.isArray(message.metadata)) return "metadata: array expected";
+ for (var i = 0; i < message.metadata.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.metadata[i]);
+ if (error) return "metadata." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates a Metric message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.Metric} Metric
+ */
+ Metric.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.Metric) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.Metric();
+ if (object.name != null) message.name = String(object.name);
+ if (object.description != null) message.description = String(object.description);
+ if (object.unit != null) message.unit = String(object.unit);
+ if (object.gauge != null) {
+ if (typeof object.gauge !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Metric.gauge: object expected");
+ message.gauge = $root.opentelemetry.proto.metrics.v1.Gauge.fromObject(object.gauge);
+ }
+ if (object.sum != null) {
+ if (typeof object.sum !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Metric.sum: object expected");
+ message.sum = $root.opentelemetry.proto.metrics.v1.Sum.fromObject(object.sum);
+ }
+ if (object.histogram != null) {
+ if (typeof object.histogram !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Metric.histogram: object expected");
+ message.histogram = $root.opentelemetry.proto.metrics.v1.Histogram.fromObject(object.histogram);
+ }
+ if (object.exponentialHistogram != null) {
+ if (typeof object.exponentialHistogram !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Metric.exponentialHistogram: object expected");
+ message.exponentialHistogram = $root.opentelemetry.proto.metrics.v1.ExponentialHistogram.fromObject(object.exponentialHistogram);
+ }
+ if (object.summary != null) {
+ if (typeof object.summary !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Metric.summary: object expected");
+ message.summary = $root.opentelemetry.proto.metrics.v1.Summary.fromObject(object.summary);
+ }
+ if (object.metadata) {
+ if (!Array.isArray(object.metadata)) throw TypeError(".opentelemetry.proto.metrics.v1.Metric.metadata: array expected");
+ message.metadata = [];
+ for (var i = 0; i < object.metadata.length; ++i) {
+ if (typeof object.metadata[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Metric.metadata: object expected");
+ message.metadata[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.metadata[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a Metric message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.Metric} message Metric
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Metric.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.metadata = [];
+ if (options.defaults) {
+ object.name = "";
+ object.description = "";
+ object.unit = "";
+ }
+ if (message.name != null && message.hasOwnProperty("name")) object.name = message.name;
+ if (message.description != null && message.hasOwnProperty("description")) object.description = message.description;
+ if (message.unit != null && message.hasOwnProperty("unit")) object.unit = message.unit;
+ if (message.gauge != null && message.hasOwnProperty("gauge")) {
+ object.gauge = $root.opentelemetry.proto.metrics.v1.Gauge.toObject(message.gauge, options);
+ if (options.oneofs) object.data = "gauge";
+ }
+ if (message.sum != null && message.hasOwnProperty("sum")) {
+ object.sum = $root.opentelemetry.proto.metrics.v1.Sum.toObject(message.sum, options);
+ if (options.oneofs) object.data = "sum";
+ }
+ if (message.histogram != null && message.hasOwnProperty("histogram")) {
+ object.histogram = $root.opentelemetry.proto.metrics.v1.Histogram.toObject(message.histogram, options);
+ if (options.oneofs) object.data = "histogram";
+ }
+ if (message.exponentialHistogram != null && message.hasOwnProperty("exponentialHistogram")) {
+ object.exponentialHistogram = $root.opentelemetry.proto.metrics.v1.ExponentialHistogram.toObject(message.exponentialHistogram, options);
+ if (options.oneofs) object.data = "exponentialHistogram";
+ }
+ if (message.summary != null && message.hasOwnProperty("summary")) {
+ object.summary = $root.opentelemetry.proto.metrics.v1.Summary.toObject(message.summary, options);
+ if (options.oneofs) object.data = "summary";
+ }
+ if (message.metadata && message.metadata.length) {
+ object.metadata = [];
+ for (var j = 0; j < message.metadata.length; ++j) object.metadata[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.metadata[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this Metric to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Metric.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Metric
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.Metric
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Metric.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.Metric";
+ };
+ return Metric;
+ })();
+ v1.Gauge = (function() {
+ /**
+ * Properties of a Gauge.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IGauge
+ * @property {Array.|null} [dataPoints] Gauge dataPoints
+ */
+ /**
+ * Constructs a new Gauge.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a Gauge.
+ * @implements IGauge
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IGauge=} [properties] Properties to set
+ */
+ function Gauge(properties) {
+ this.dataPoints = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Gauge dataPoints.
+ * @member {Array.} dataPoints
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @instance
+ */
+ Gauge.prototype.dataPoints = $util.emptyArray;
+ /**
+ * Creates a new Gauge instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IGauge=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.Gauge} Gauge instance
+ */
+ Gauge.create = function create(properties) {
+ return new Gauge(properties);
+ };
+ /**
+ * Encodes the specified Gauge message. Does not implicitly {@link opentelemetry.proto.metrics.v1.Gauge.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IGauge} message Gauge message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Gauge.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.dataPoints != null && message.dataPoints.length) for (var i = 0; i < message.dataPoints.length; ++i) $root.opentelemetry.proto.metrics.v1.NumberDataPoint.encode(message.dataPoints[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified Gauge message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.Gauge.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IGauge} message Gauge message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Gauge.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Gauge message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.Gauge} Gauge
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Gauge.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.Gauge();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.dataPoints && message.dataPoints.length)) message.dataPoints = [];
+ message.dataPoints.push($root.opentelemetry.proto.metrics.v1.NumberDataPoint.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Gauge message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.Gauge} Gauge
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Gauge.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Gauge message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Gauge.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.dataPoints != null && message.hasOwnProperty("dataPoints")) {
+ if (!Array.isArray(message.dataPoints)) return "dataPoints: array expected";
+ for (var i = 0; i < message.dataPoints.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.NumberDataPoint.verify(message.dataPoints[i]);
+ if (error) return "dataPoints." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates a Gauge message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.Gauge} Gauge
+ */
+ Gauge.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.Gauge) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.Gauge();
+ if (object.dataPoints) {
+ if (!Array.isArray(object.dataPoints)) throw TypeError(".opentelemetry.proto.metrics.v1.Gauge.dataPoints: array expected");
+ message.dataPoints = [];
+ for (var i = 0; i < object.dataPoints.length; ++i) {
+ if (typeof object.dataPoints[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Gauge.dataPoints: object expected");
+ message.dataPoints[i] = $root.opentelemetry.proto.metrics.v1.NumberDataPoint.fromObject(object.dataPoints[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a Gauge message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.Gauge} message Gauge
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Gauge.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.dataPoints = [];
+ if (message.dataPoints && message.dataPoints.length) {
+ object.dataPoints = [];
+ for (var j = 0; j < message.dataPoints.length; ++j) object.dataPoints[j] = $root.opentelemetry.proto.metrics.v1.NumberDataPoint.toObject(message.dataPoints[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this Gauge to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Gauge.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Gauge
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.Gauge
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Gauge.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.Gauge";
+ };
+ return Gauge;
+ })();
+ v1.Sum = (function() {
+ /**
+ * Properties of a Sum.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface ISum
+ * @property {Array.|null} [dataPoints] Sum dataPoints
+ * @property {opentelemetry.proto.metrics.v1.AggregationTemporality|null} [aggregationTemporality] Sum aggregationTemporality
+ * @property {boolean|null} [isMonotonic] Sum isMonotonic
+ */
+ /**
+ * Constructs a new Sum.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a Sum.
+ * @implements ISum
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.ISum=} [properties] Properties to set
+ */
+ function Sum(properties) {
+ this.dataPoints = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Sum dataPoints.
+ * @member {Array.} dataPoints
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @instance
+ */
+ Sum.prototype.dataPoints = $util.emptyArray;
+ /**
+ * Sum aggregationTemporality.
+ * @member {opentelemetry.proto.metrics.v1.AggregationTemporality|null|undefined} aggregationTemporality
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @instance
+ */
+ Sum.prototype.aggregationTemporality = null;
+ /**
+ * Sum isMonotonic.
+ * @member {boolean|null|undefined} isMonotonic
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @instance
+ */
+ Sum.prototype.isMonotonic = null;
+ /**
+ * Creates a new Sum instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ISum=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.Sum} Sum instance
+ */
+ Sum.create = function create(properties) {
+ return new Sum(properties);
+ };
+ /**
+ * Encodes the specified Sum message. Does not implicitly {@link opentelemetry.proto.metrics.v1.Sum.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ISum} message Sum message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Sum.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.dataPoints != null && message.dataPoints.length) for (var i = 0; i < message.dataPoints.length; ++i) $root.opentelemetry.proto.metrics.v1.NumberDataPoint.encode(message.dataPoints[i], writer.uint32(10).fork()).ldelim();
+ if (message.aggregationTemporality != null && Object.hasOwnProperty.call(message, "aggregationTemporality")) writer.uint32(16).int32(message.aggregationTemporality);
+ if (message.isMonotonic != null && Object.hasOwnProperty.call(message, "isMonotonic")) writer.uint32(24).bool(message.isMonotonic);
+ return writer;
+ };
+ /**
+ * Encodes the specified Sum message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.Sum.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ISum} message Sum message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Sum.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Sum message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.Sum} Sum
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Sum.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.Sum();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.dataPoints && message.dataPoints.length)) message.dataPoints = [];
+ message.dataPoints.push($root.opentelemetry.proto.metrics.v1.NumberDataPoint.decode(reader, reader.uint32()));
+ break;
+ case 2:
+ message.aggregationTemporality = reader.int32();
+ break;
+ case 3:
+ message.isMonotonic = reader.bool();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Sum message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.Sum} Sum
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Sum.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Sum message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Sum.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.dataPoints != null && message.hasOwnProperty("dataPoints")) {
+ if (!Array.isArray(message.dataPoints)) return "dataPoints: array expected";
+ for (var i = 0; i < message.dataPoints.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.NumberDataPoint.verify(message.dataPoints[i]);
+ if (error) return "dataPoints." + error;
+ }
+ }
+ if (message.aggregationTemporality != null && message.hasOwnProperty("aggregationTemporality")) switch (message.aggregationTemporality) {
+ default: return "aggregationTemporality: enum value expected";
+ case 0:
+ case 1:
+ case 2: break;
+ }
+ if (message.isMonotonic != null && message.hasOwnProperty("isMonotonic")) {
+ if (typeof message.isMonotonic !== "boolean") return "isMonotonic: boolean expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a Sum message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.Sum} Sum
+ */
+ Sum.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.Sum) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.Sum();
+ if (object.dataPoints) {
+ if (!Array.isArray(object.dataPoints)) throw TypeError(".opentelemetry.proto.metrics.v1.Sum.dataPoints: array expected");
+ message.dataPoints = [];
+ for (var i = 0; i < object.dataPoints.length; ++i) {
+ if (typeof object.dataPoints[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Sum.dataPoints: object expected");
+ message.dataPoints[i] = $root.opentelemetry.proto.metrics.v1.NumberDataPoint.fromObject(object.dataPoints[i]);
+ }
+ }
+ switch (object.aggregationTemporality) {
+ default:
+ if (typeof object.aggregationTemporality === "number") {
+ message.aggregationTemporality = object.aggregationTemporality;
+ break;
+ }
+ break;
+ case "AGGREGATION_TEMPORALITY_UNSPECIFIED":
+ case 0:
+ message.aggregationTemporality = 0;
+ break;
+ case "AGGREGATION_TEMPORALITY_DELTA":
+ case 1:
+ message.aggregationTemporality = 1;
+ break;
+ case "AGGREGATION_TEMPORALITY_CUMULATIVE":
+ case 2:
+ message.aggregationTemporality = 2;
+ break;
+ }
+ if (object.isMonotonic != null) message.isMonotonic = Boolean(object.isMonotonic);
+ return message;
+ };
+ /**
+ * Creates a plain object from a Sum message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.Sum} message Sum
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Sum.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.dataPoints = [];
+ if (options.defaults) {
+ object.aggregationTemporality = options.enums === String ? "AGGREGATION_TEMPORALITY_UNSPECIFIED" : 0;
+ object.isMonotonic = false;
+ }
+ if (message.dataPoints && message.dataPoints.length) {
+ object.dataPoints = [];
+ for (var j = 0; j < message.dataPoints.length; ++j) object.dataPoints[j] = $root.opentelemetry.proto.metrics.v1.NumberDataPoint.toObject(message.dataPoints[j], options);
+ }
+ if (message.aggregationTemporality != null && message.hasOwnProperty("aggregationTemporality")) object.aggregationTemporality = options.enums === String ? $root.opentelemetry.proto.metrics.v1.AggregationTemporality[message.aggregationTemporality] === void 0 ? message.aggregationTemporality : $root.opentelemetry.proto.metrics.v1.AggregationTemporality[message.aggregationTemporality] : message.aggregationTemporality;
+ if (message.isMonotonic != null && message.hasOwnProperty("isMonotonic")) object.isMonotonic = message.isMonotonic;
+ return object;
+ };
+ /**
+ * Converts this Sum to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Sum.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Sum
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.Sum
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Sum.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.Sum";
+ };
+ return Sum;
+ })();
+ v1.Histogram = (function() {
+ /**
+ * Properties of a Histogram.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IHistogram
+ * @property {Array.|null} [dataPoints] Histogram dataPoints
+ * @property {opentelemetry.proto.metrics.v1.AggregationTemporality|null} [aggregationTemporality] Histogram aggregationTemporality
+ */
+ /**
+ * Constructs a new Histogram.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a Histogram.
+ * @implements IHistogram
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IHistogram=} [properties] Properties to set
+ */
+ function Histogram(properties) {
+ this.dataPoints = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Histogram dataPoints.
+ * @member {Array.} dataPoints
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @instance
+ */
+ Histogram.prototype.dataPoints = $util.emptyArray;
+ /**
+ * Histogram aggregationTemporality.
+ * @member {opentelemetry.proto.metrics.v1.AggregationTemporality|null|undefined} aggregationTemporality
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @instance
+ */
+ Histogram.prototype.aggregationTemporality = null;
+ /**
+ * Creates a new Histogram instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IHistogram=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.Histogram} Histogram instance
+ */
+ Histogram.create = function create(properties) {
+ return new Histogram(properties);
+ };
+ /**
+ * Encodes the specified Histogram message. Does not implicitly {@link opentelemetry.proto.metrics.v1.Histogram.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IHistogram} message Histogram message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Histogram.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.dataPoints != null && message.dataPoints.length) for (var i = 0; i < message.dataPoints.length; ++i) $root.opentelemetry.proto.metrics.v1.HistogramDataPoint.encode(message.dataPoints[i], writer.uint32(10).fork()).ldelim();
+ if (message.aggregationTemporality != null && Object.hasOwnProperty.call(message, "aggregationTemporality")) writer.uint32(16).int32(message.aggregationTemporality);
+ return writer;
+ };
+ /**
+ * Encodes the specified Histogram message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.Histogram.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IHistogram} message Histogram message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Histogram.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Histogram message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.Histogram} Histogram
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Histogram.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.Histogram();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.dataPoints && message.dataPoints.length)) message.dataPoints = [];
+ message.dataPoints.push($root.opentelemetry.proto.metrics.v1.HistogramDataPoint.decode(reader, reader.uint32()));
+ break;
+ case 2:
+ message.aggregationTemporality = reader.int32();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Histogram message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.Histogram} Histogram
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Histogram.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Histogram message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Histogram.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.dataPoints != null && message.hasOwnProperty("dataPoints")) {
+ if (!Array.isArray(message.dataPoints)) return "dataPoints: array expected";
+ for (var i = 0; i < message.dataPoints.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.HistogramDataPoint.verify(message.dataPoints[i]);
+ if (error) return "dataPoints." + error;
+ }
+ }
+ if (message.aggregationTemporality != null && message.hasOwnProperty("aggregationTemporality")) switch (message.aggregationTemporality) {
+ default: return "aggregationTemporality: enum value expected";
+ case 0:
+ case 1:
+ case 2: break;
+ }
+ return null;
+ };
+ /**
+ * Creates a Histogram message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.Histogram} Histogram
+ */
+ Histogram.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.Histogram) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.Histogram();
+ if (object.dataPoints) {
+ if (!Array.isArray(object.dataPoints)) throw TypeError(".opentelemetry.proto.metrics.v1.Histogram.dataPoints: array expected");
+ message.dataPoints = [];
+ for (var i = 0; i < object.dataPoints.length; ++i) {
+ if (typeof object.dataPoints[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Histogram.dataPoints: object expected");
+ message.dataPoints[i] = $root.opentelemetry.proto.metrics.v1.HistogramDataPoint.fromObject(object.dataPoints[i]);
+ }
+ }
+ switch (object.aggregationTemporality) {
+ default:
+ if (typeof object.aggregationTemporality === "number") {
+ message.aggregationTemporality = object.aggregationTemporality;
+ break;
+ }
+ break;
+ case "AGGREGATION_TEMPORALITY_UNSPECIFIED":
+ case 0:
+ message.aggregationTemporality = 0;
+ break;
+ case "AGGREGATION_TEMPORALITY_DELTA":
+ case 1:
+ message.aggregationTemporality = 1;
+ break;
+ case "AGGREGATION_TEMPORALITY_CUMULATIVE":
+ case 2:
+ message.aggregationTemporality = 2;
+ break;
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a Histogram message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.Histogram} message Histogram
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Histogram.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.dataPoints = [];
+ if (options.defaults) object.aggregationTemporality = options.enums === String ? "AGGREGATION_TEMPORALITY_UNSPECIFIED" : 0;
+ if (message.dataPoints && message.dataPoints.length) {
+ object.dataPoints = [];
+ for (var j = 0; j < message.dataPoints.length; ++j) object.dataPoints[j] = $root.opentelemetry.proto.metrics.v1.HistogramDataPoint.toObject(message.dataPoints[j], options);
+ }
+ if (message.aggregationTemporality != null && message.hasOwnProperty("aggregationTemporality")) object.aggregationTemporality = options.enums === String ? $root.opentelemetry.proto.metrics.v1.AggregationTemporality[message.aggregationTemporality] === void 0 ? message.aggregationTemporality : $root.opentelemetry.proto.metrics.v1.AggregationTemporality[message.aggregationTemporality] : message.aggregationTemporality;
+ return object;
+ };
+ /**
+ * Converts this Histogram to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Histogram.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Histogram
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.Histogram
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Histogram.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.Histogram";
+ };
+ return Histogram;
+ })();
+ v1.ExponentialHistogram = (function() {
+ /**
+ * Properties of an ExponentialHistogram.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IExponentialHistogram
+ * @property {Array.|null} [dataPoints] ExponentialHistogram dataPoints
+ * @property {opentelemetry.proto.metrics.v1.AggregationTemporality|null} [aggregationTemporality] ExponentialHistogram aggregationTemporality
+ */
+ /**
+ * Constructs a new ExponentialHistogram.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents an ExponentialHistogram.
+ * @implements IExponentialHistogram
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IExponentialHistogram=} [properties] Properties to set
+ */
+ function ExponentialHistogram(properties) {
+ this.dataPoints = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExponentialHistogram dataPoints.
+ * @member {Array.} dataPoints
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @instance
+ */
+ ExponentialHistogram.prototype.dataPoints = $util.emptyArray;
+ /**
+ * ExponentialHistogram aggregationTemporality.
+ * @member {opentelemetry.proto.metrics.v1.AggregationTemporality|null|undefined} aggregationTemporality
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @instance
+ */
+ ExponentialHistogram.prototype.aggregationTemporality = null;
+ /**
+ * Creates a new ExponentialHistogram instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IExponentialHistogram=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogram} ExponentialHistogram instance
+ */
+ ExponentialHistogram.create = function create(properties) {
+ return new ExponentialHistogram(properties);
+ };
+ /**
+ * Encodes the specified ExponentialHistogram message. Does not implicitly {@link opentelemetry.proto.metrics.v1.ExponentialHistogram.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IExponentialHistogram} message ExponentialHistogram message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExponentialHistogram.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.dataPoints != null && message.dataPoints.length) for (var i = 0; i < message.dataPoints.length; ++i) $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.encode(message.dataPoints[i], writer.uint32(10).fork()).ldelim();
+ if (message.aggregationTemporality != null && Object.hasOwnProperty.call(message, "aggregationTemporality")) writer.uint32(16).int32(message.aggregationTemporality);
+ return writer;
+ };
+ /**
+ * Encodes the specified ExponentialHistogram message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.ExponentialHistogram.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IExponentialHistogram} message ExponentialHistogram message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExponentialHistogram.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExponentialHistogram message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogram} ExponentialHistogram
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExponentialHistogram.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.ExponentialHistogram();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.dataPoints && message.dataPoints.length)) message.dataPoints = [];
+ message.dataPoints.push($root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.decode(reader, reader.uint32()));
+ break;
+ case 2:
+ message.aggregationTemporality = reader.int32();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExponentialHistogram message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogram} ExponentialHistogram
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExponentialHistogram.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExponentialHistogram message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExponentialHistogram.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.dataPoints != null && message.hasOwnProperty("dataPoints")) {
+ if (!Array.isArray(message.dataPoints)) return "dataPoints: array expected";
+ for (var i = 0; i < message.dataPoints.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.verify(message.dataPoints[i]);
+ if (error) return "dataPoints." + error;
+ }
+ }
+ if (message.aggregationTemporality != null && message.hasOwnProperty("aggregationTemporality")) switch (message.aggregationTemporality) {
+ default: return "aggregationTemporality: enum value expected";
+ case 0:
+ case 1:
+ case 2: break;
+ }
+ return null;
+ };
+ /**
+ * Creates an ExponentialHistogram message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogram} ExponentialHistogram
+ */
+ ExponentialHistogram.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.ExponentialHistogram) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.ExponentialHistogram();
+ if (object.dataPoints) {
+ if (!Array.isArray(object.dataPoints)) throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogram.dataPoints: array expected");
+ message.dataPoints = [];
+ for (var i = 0; i < object.dataPoints.length; ++i) {
+ if (typeof object.dataPoints[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogram.dataPoints: object expected");
+ message.dataPoints[i] = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.fromObject(object.dataPoints[i]);
+ }
+ }
+ switch (object.aggregationTemporality) {
+ default:
+ if (typeof object.aggregationTemporality === "number") {
+ message.aggregationTemporality = object.aggregationTemporality;
+ break;
+ }
+ break;
+ case "AGGREGATION_TEMPORALITY_UNSPECIFIED":
+ case 0:
+ message.aggregationTemporality = 0;
+ break;
+ case "AGGREGATION_TEMPORALITY_DELTA":
+ case 1:
+ message.aggregationTemporality = 1;
+ break;
+ case "AGGREGATION_TEMPORALITY_CUMULATIVE":
+ case 2:
+ message.aggregationTemporality = 2;
+ break;
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExponentialHistogram message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ExponentialHistogram} message ExponentialHistogram
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExponentialHistogram.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.dataPoints = [];
+ if (options.defaults) object.aggregationTemporality = options.enums === String ? "AGGREGATION_TEMPORALITY_UNSPECIFIED" : 0;
+ if (message.dataPoints && message.dataPoints.length) {
+ object.dataPoints = [];
+ for (var j = 0; j < message.dataPoints.length; ++j) object.dataPoints[j] = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.toObject(message.dataPoints[j], options);
+ }
+ if (message.aggregationTemporality != null && message.hasOwnProperty("aggregationTemporality")) object.aggregationTemporality = options.enums === String ? $root.opentelemetry.proto.metrics.v1.AggregationTemporality[message.aggregationTemporality] === void 0 ? message.aggregationTemporality : $root.opentelemetry.proto.metrics.v1.AggregationTemporality[message.aggregationTemporality] : message.aggregationTemporality;
+ return object;
+ };
+ /**
+ * Converts this ExponentialHistogram to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExponentialHistogram.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExponentialHistogram
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogram
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExponentialHistogram.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.ExponentialHistogram";
+ };
+ return ExponentialHistogram;
+ })();
+ v1.Summary = (function() {
+ /**
+ * Properties of a Summary.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface ISummary
+ * @property {Array.|null} [dataPoints] Summary dataPoints
+ */
+ /**
+ * Constructs a new Summary.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a Summary.
+ * @implements ISummary
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.ISummary=} [properties] Properties to set
+ */
+ function Summary(properties) {
+ this.dataPoints = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Summary dataPoints.
+ * @member {Array.} dataPoints
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @instance
+ */
+ Summary.prototype.dataPoints = $util.emptyArray;
+ /**
+ * Creates a new Summary instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ISummary=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.Summary} Summary instance
+ */
+ Summary.create = function create(properties) {
+ return new Summary(properties);
+ };
+ /**
+ * Encodes the specified Summary message. Does not implicitly {@link opentelemetry.proto.metrics.v1.Summary.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ISummary} message Summary message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Summary.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.dataPoints != null && message.dataPoints.length) for (var i = 0; i < message.dataPoints.length; ++i) $root.opentelemetry.proto.metrics.v1.SummaryDataPoint.encode(message.dataPoints[i], writer.uint32(10).fork()).ldelim();
+ return writer;
+ };
+ /**
+ * Encodes the specified Summary message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.Summary.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ISummary} message Summary message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Summary.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Summary message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.Summary} Summary
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Summary.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.Summary();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.dataPoints && message.dataPoints.length)) message.dataPoints = [];
+ message.dataPoints.push($root.opentelemetry.proto.metrics.v1.SummaryDataPoint.decode(reader, reader.uint32()));
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Summary message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.Summary} Summary
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Summary.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Summary message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Summary.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.dataPoints != null && message.hasOwnProperty("dataPoints")) {
+ if (!Array.isArray(message.dataPoints)) return "dataPoints: array expected";
+ for (var i = 0; i < message.dataPoints.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.SummaryDataPoint.verify(message.dataPoints[i]);
+ if (error) return "dataPoints." + error;
+ }
+ }
+ return null;
+ };
+ /**
+ * Creates a Summary message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.Summary} Summary
+ */
+ Summary.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.Summary) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.Summary();
+ if (object.dataPoints) {
+ if (!Array.isArray(object.dataPoints)) throw TypeError(".opentelemetry.proto.metrics.v1.Summary.dataPoints: array expected");
+ message.dataPoints = [];
+ for (var i = 0; i < object.dataPoints.length; ++i) {
+ if (typeof object.dataPoints[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.Summary.dataPoints: object expected");
+ message.dataPoints[i] = $root.opentelemetry.proto.metrics.v1.SummaryDataPoint.fromObject(object.dataPoints[i]);
+ }
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a Summary message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.Summary} message Summary
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Summary.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.dataPoints = [];
+ if (message.dataPoints && message.dataPoints.length) {
+ object.dataPoints = [];
+ for (var j = 0; j < message.dataPoints.length; ++j) object.dataPoints[j] = $root.opentelemetry.proto.metrics.v1.SummaryDataPoint.toObject(message.dataPoints[j], options);
+ }
+ return object;
+ };
+ /**
+ * Converts this Summary to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ Summary.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for Summary
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.Summary
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ Summary.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.Summary";
+ };
+ return Summary;
+ })();
+ /**
+ * AggregationTemporality enum.
+ * @name opentelemetry.proto.metrics.v1.AggregationTemporality
+ * @enum {number}
+ * @property {number} AGGREGATION_TEMPORALITY_UNSPECIFIED=0 AGGREGATION_TEMPORALITY_UNSPECIFIED value
+ * @property {number} AGGREGATION_TEMPORALITY_DELTA=1 AGGREGATION_TEMPORALITY_DELTA value
+ * @property {number} AGGREGATION_TEMPORALITY_CUMULATIVE=2 AGGREGATION_TEMPORALITY_CUMULATIVE value
+ */
+ v1.AggregationTemporality = (function() {
+ var valuesById = {}, values = Object.create(valuesById);
+ values[valuesById[0] = "AGGREGATION_TEMPORALITY_UNSPECIFIED"] = 0;
+ values[valuesById[1] = "AGGREGATION_TEMPORALITY_DELTA"] = 1;
+ values[valuesById[2] = "AGGREGATION_TEMPORALITY_CUMULATIVE"] = 2;
+ return values;
+ })();
+ /**
+ * DataPointFlags enum.
+ * @name opentelemetry.proto.metrics.v1.DataPointFlags
+ * @enum {number}
+ * @property {number} DATA_POINT_FLAGS_DO_NOT_USE=0 DATA_POINT_FLAGS_DO_NOT_USE value
+ * @property {number} DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK=1 DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK value
+ */
+ v1.DataPointFlags = (function() {
+ var valuesById = {}, values = Object.create(valuesById);
+ values[valuesById[0] = "DATA_POINT_FLAGS_DO_NOT_USE"] = 0;
+ values[valuesById[1] = "DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK"] = 1;
+ return values;
+ })();
+ v1.NumberDataPoint = (function() {
+ /**
+ * Properties of a NumberDataPoint.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface INumberDataPoint
+ * @property {Array.|null} [attributes] NumberDataPoint attributes
+ * @property {number|Long|null} [startTimeUnixNano] NumberDataPoint startTimeUnixNano
+ * @property {number|Long|null} [timeUnixNano] NumberDataPoint timeUnixNano
+ * @property {number|null} [asDouble] NumberDataPoint asDouble
+ * @property {number|Long|null} [asInt] NumberDataPoint asInt
+ * @property {Array.|null} [exemplars] NumberDataPoint exemplars
+ * @property {number|null} [flags] NumberDataPoint flags
+ */
+ /**
+ * Constructs a new NumberDataPoint.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a NumberDataPoint.
+ * @implements INumberDataPoint
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.INumberDataPoint=} [properties] Properties to set
+ */
+ function NumberDataPoint(properties) {
+ this.attributes = [];
+ this.exemplars = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * NumberDataPoint attributes.
+ * @member {Array.} attributes
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ */
+ NumberDataPoint.prototype.attributes = $util.emptyArray;
+ /**
+ * NumberDataPoint startTimeUnixNano.
+ * @member {number|Long|null|undefined} startTimeUnixNano
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ */
+ NumberDataPoint.prototype.startTimeUnixNano = null;
+ /**
+ * NumberDataPoint timeUnixNano.
+ * @member {number|Long|null|undefined} timeUnixNano
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ */
+ NumberDataPoint.prototype.timeUnixNano = null;
+ /**
+ * NumberDataPoint asDouble.
+ * @member {number|null|undefined} asDouble
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ */
+ NumberDataPoint.prototype.asDouble = null;
+ /**
+ * NumberDataPoint asInt.
+ * @member {number|Long|null|undefined} asInt
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ */
+ NumberDataPoint.prototype.asInt = null;
+ /**
+ * NumberDataPoint exemplars.
+ * @member {Array.} exemplars
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ */
+ NumberDataPoint.prototype.exemplars = $util.emptyArray;
+ /**
+ * NumberDataPoint flags.
+ * @member {number|null|undefined} flags
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ */
+ NumberDataPoint.prototype.flags = null;
+ var $oneOfFields;
+ /**
+ * NumberDataPoint value.
+ * @member {"asDouble"|"asInt"|undefined} value
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ */
+ Object.defineProperty(NumberDataPoint.prototype, "value", {
+ get: $util.oneOfGetter($oneOfFields = ["asDouble", "asInt"]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * Creates a new NumberDataPoint instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.INumberDataPoint=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.NumberDataPoint} NumberDataPoint instance
+ */
+ NumberDataPoint.create = function create(properties) {
+ return new NumberDataPoint(properties);
+ };
+ /**
+ * Encodes the specified NumberDataPoint message. Does not implicitly {@link opentelemetry.proto.metrics.v1.NumberDataPoint.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.INumberDataPoint} message NumberDataPoint message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ NumberDataPoint.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.startTimeUnixNano != null && Object.hasOwnProperty.call(message, "startTimeUnixNano")) writer.uint32(17).fixed64(message.startTimeUnixNano);
+ if (message.timeUnixNano != null && Object.hasOwnProperty.call(message, "timeUnixNano")) writer.uint32(25).fixed64(message.timeUnixNano);
+ if (message.asDouble != null && Object.hasOwnProperty.call(message, "asDouble")) writer.uint32(33).double(message.asDouble);
+ if (message.exemplars != null && message.exemplars.length) for (var i = 0; i < message.exemplars.length; ++i) $root.opentelemetry.proto.metrics.v1.Exemplar.encode(message.exemplars[i], writer.uint32(42).fork()).ldelim();
+ if (message.asInt != null && Object.hasOwnProperty.call(message, "asInt")) writer.uint32(49).sfixed64(message.asInt);
+ if (message.attributes != null && message.attributes.length) for (var i = 0; i < message.attributes.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.attributes[i], writer.uint32(58).fork()).ldelim();
+ if (message.flags != null && Object.hasOwnProperty.call(message, "flags")) writer.uint32(64).uint32(message.flags);
+ return writer;
+ };
+ /**
+ * Encodes the specified NumberDataPoint message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.NumberDataPoint.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.INumberDataPoint} message NumberDataPoint message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ NumberDataPoint.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a NumberDataPoint message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.NumberDataPoint} NumberDataPoint
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ NumberDataPoint.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.NumberDataPoint();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 7:
+ if (!(message.attributes && message.attributes.length)) message.attributes = [];
+ message.attributes.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ case 2:
+ message.startTimeUnixNano = reader.fixed64();
+ break;
+ case 3:
+ message.timeUnixNano = reader.fixed64();
+ break;
+ case 4:
+ message.asDouble = reader.double();
+ break;
+ case 6:
+ message.asInt = reader.sfixed64();
+ break;
+ case 5:
+ if (!(message.exemplars && message.exemplars.length)) message.exemplars = [];
+ message.exemplars.push($root.opentelemetry.proto.metrics.v1.Exemplar.decode(reader, reader.uint32()));
+ break;
+ case 8:
+ message.flags = reader.uint32();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a NumberDataPoint message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.NumberDataPoint} NumberDataPoint
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ NumberDataPoint.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a NumberDataPoint message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ NumberDataPoint.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ var properties = {};
+ if (message.attributes != null && message.hasOwnProperty("attributes")) {
+ if (!Array.isArray(message.attributes)) return "attributes: array expected";
+ for (var i = 0; i < message.attributes.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.attributes[i]);
+ if (error) return "attributes." + error;
+ }
+ }
+ if (message.startTimeUnixNano != null && message.hasOwnProperty("startTimeUnixNano")) {
+ if (!$util.isInteger(message.startTimeUnixNano) && !(message.startTimeUnixNano && $util.isInteger(message.startTimeUnixNano.low) && $util.isInteger(message.startTimeUnixNano.high))) return "startTimeUnixNano: integer|Long expected";
+ }
+ if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) {
+ if (!$util.isInteger(message.timeUnixNano) && !(message.timeUnixNano && $util.isInteger(message.timeUnixNano.low) && $util.isInteger(message.timeUnixNano.high))) return "timeUnixNano: integer|Long expected";
+ }
+ if (message.asDouble != null && message.hasOwnProperty("asDouble")) {
+ properties.value = 1;
+ if (typeof message.asDouble !== "number") return "asDouble: number expected";
+ }
+ if (message.asInt != null && message.hasOwnProperty("asInt")) {
+ if (properties.value === 1) return "value: multiple values";
+ properties.value = 1;
+ if (!$util.isInteger(message.asInt) && !(message.asInt && $util.isInteger(message.asInt.low) && $util.isInteger(message.asInt.high))) return "asInt: integer|Long expected";
+ }
+ if (message.exemplars != null && message.hasOwnProperty("exemplars")) {
+ if (!Array.isArray(message.exemplars)) return "exemplars: array expected";
+ for (var i = 0; i < message.exemplars.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.Exemplar.verify(message.exemplars[i]);
+ if (error) return "exemplars." + error;
+ }
+ }
+ if (message.flags != null && message.hasOwnProperty("flags")) {
+ if (!$util.isInteger(message.flags)) return "flags: integer expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a NumberDataPoint message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.NumberDataPoint} NumberDataPoint
+ */
+ NumberDataPoint.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.NumberDataPoint) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.NumberDataPoint();
+ if (object.attributes) {
+ if (!Array.isArray(object.attributes)) throw TypeError(".opentelemetry.proto.metrics.v1.NumberDataPoint.attributes: array expected");
+ message.attributes = [];
+ for (var i = 0; i < object.attributes.length; ++i) {
+ if (typeof object.attributes[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.NumberDataPoint.attributes: object expected");
+ message.attributes[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.attributes[i]);
+ }
+ }
+ if (object.startTimeUnixNano != null) {
+ if ($util.Long) (message.startTimeUnixNano = $util.Long.fromValue(object.startTimeUnixNano)).unsigned = false;
+ else if (typeof object.startTimeUnixNano === "string") message.startTimeUnixNano = parseInt(object.startTimeUnixNano, 10);
+ else if (typeof object.startTimeUnixNano === "number") message.startTimeUnixNano = object.startTimeUnixNano;
+ else if (typeof object.startTimeUnixNano === "object") message.startTimeUnixNano = new $util.LongBits(object.startTimeUnixNano.low >>> 0, object.startTimeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.timeUnixNano != null) {
+ if ($util.Long) (message.timeUnixNano = $util.Long.fromValue(object.timeUnixNano)).unsigned = false;
+ else if (typeof object.timeUnixNano === "string") message.timeUnixNano = parseInt(object.timeUnixNano, 10);
+ else if (typeof object.timeUnixNano === "number") message.timeUnixNano = object.timeUnixNano;
+ else if (typeof object.timeUnixNano === "object") message.timeUnixNano = new $util.LongBits(object.timeUnixNano.low >>> 0, object.timeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.asDouble != null) message.asDouble = Number(object.asDouble);
+ if (object.asInt != null) {
+ if ($util.Long) (message.asInt = $util.Long.fromValue(object.asInt)).unsigned = false;
+ else if (typeof object.asInt === "string") message.asInt = parseInt(object.asInt, 10);
+ else if (typeof object.asInt === "number") message.asInt = object.asInt;
+ else if (typeof object.asInt === "object") message.asInt = new $util.LongBits(object.asInt.low >>> 0, object.asInt.high >>> 0).toNumber();
+ }
+ if (object.exemplars) {
+ if (!Array.isArray(object.exemplars)) throw TypeError(".opentelemetry.proto.metrics.v1.NumberDataPoint.exemplars: array expected");
+ message.exemplars = [];
+ for (var i = 0; i < object.exemplars.length; ++i) {
+ if (typeof object.exemplars[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.NumberDataPoint.exemplars: object expected");
+ message.exemplars[i] = $root.opentelemetry.proto.metrics.v1.Exemplar.fromObject(object.exemplars[i]);
+ }
+ }
+ if (object.flags != null) message.flags = object.flags >>> 0;
+ return message;
+ };
+ /**
+ * Creates a plain object from a NumberDataPoint message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.NumberDataPoint} message NumberDataPoint
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ NumberDataPoint.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) {
+ object.exemplars = [];
+ object.attributes = [];
+ }
+ if (options.defaults) {
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.startTimeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.startTimeUnixNano = options.longs === String ? "0" : 0;
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.timeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.timeUnixNano = options.longs === String ? "0" : 0;
+ object.flags = 0;
+ }
+ if (message.startTimeUnixNano != null && message.hasOwnProperty("startTimeUnixNano")) if (typeof message.startTimeUnixNano === "number") object.startTimeUnixNano = options.longs === String ? String(message.startTimeUnixNano) : message.startTimeUnixNano;
+ else object.startTimeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.startTimeUnixNano) : options.longs === Number ? new $util.LongBits(message.startTimeUnixNano.low >>> 0, message.startTimeUnixNano.high >>> 0).toNumber() : message.startTimeUnixNano;
+ if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) if (typeof message.timeUnixNano === "number") object.timeUnixNano = options.longs === String ? String(message.timeUnixNano) : message.timeUnixNano;
+ else object.timeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.timeUnixNano) : options.longs === Number ? new $util.LongBits(message.timeUnixNano.low >>> 0, message.timeUnixNano.high >>> 0).toNumber() : message.timeUnixNano;
+ if (message.asDouble != null && message.hasOwnProperty("asDouble")) {
+ object.asDouble = options.json && !isFinite(message.asDouble) ? String(message.asDouble) : message.asDouble;
+ if (options.oneofs) object.value = "asDouble";
+ }
+ if (message.exemplars && message.exemplars.length) {
+ object.exemplars = [];
+ for (var j = 0; j < message.exemplars.length; ++j) object.exemplars[j] = $root.opentelemetry.proto.metrics.v1.Exemplar.toObject(message.exemplars[j], options);
+ }
+ if (message.asInt != null && message.hasOwnProperty("asInt")) {
+ if (typeof message.asInt === "number") object.asInt = options.longs === String ? String(message.asInt) : message.asInt;
+ else object.asInt = options.longs === String ? $util.Long.prototype.toString.call(message.asInt) : options.longs === Number ? new $util.LongBits(message.asInt.low >>> 0, message.asInt.high >>> 0).toNumber() : message.asInt;
+ if (options.oneofs) object.value = "asInt";
+ }
+ if (message.attributes && message.attributes.length) {
+ object.attributes = [];
+ for (var j = 0; j < message.attributes.length; ++j) object.attributes[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.attributes[j], options);
+ }
+ if (message.flags != null && message.hasOwnProperty("flags")) object.flags = message.flags;
+ return object;
+ };
+ /**
+ * Converts this NumberDataPoint to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ NumberDataPoint.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for NumberDataPoint
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.NumberDataPoint
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ NumberDataPoint.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.NumberDataPoint";
+ };
+ return NumberDataPoint;
+ })();
+ v1.HistogramDataPoint = (function() {
+ /**
+ * Properties of a HistogramDataPoint.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IHistogramDataPoint
+ * @property {Array.|null} [attributes] HistogramDataPoint attributes
+ * @property {number|Long|null} [startTimeUnixNano] HistogramDataPoint startTimeUnixNano
+ * @property {number|Long|null} [timeUnixNano] HistogramDataPoint timeUnixNano
+ * @property {number|Long|null} [count] HistogramDataPoint count
+ * @property {number|null} [sum] HistogramDataPoint sum
+ * @property {Array.|null} [bucketCounts] HistogramDataPoint bucketCounts
+ * @property {Array.|null} [explicitBounds] HistogramDataPoint explicitBounds
+ * @property {Array.|null} [exemplars] HistogramDataPoint exemplars
+ * @property {number|null} [flags] HistogramDataPoint flags
+ * @property {number|null} [min] HistogramDataPoint min
+ * @property {number|null} [max] HistogramDataPoint max
+ */
+ /**
+ * Constructs a new HistogramDataPoint.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents a HistogramDataPoint.
+ * @implements IHistogramDataPoint
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IHistogramDataPoint=} [properties] Properties to set
+ */
+ function HistogramDataPoint(properties) {
+ this.attributes = [];
+ this.bucketCounts = [];
+ this.explicitBounds = [];
+ this.exemplars = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * HistogramDataPoint attributes.
+ * @member {Array.} attributes
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.attributes = $util.emptyArray;
+ /**
+ * HistogramDataPoint startTimeUnixNano.
+ * @member {number|Long|null|undefined} startTimeUnixNano
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.startTimeUnixNano = null;
+ /**
+ * HistogramDataPoint timeUnixNano.
+ * @member {number|Long|null|undefined} timeUnixNano
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.timeUnixNano = null;
+ /**
+ * HistogramDataPoint count.
+ * @member {number|Long|null|undefined} count
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.count = null;
+ /**
+ * HistogramDataPoint sum.
+ * @member {number|null|undefined} sum
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.sum = null;
+ /**
+ * HistogramDataPoint bucketCounts.
+ * @member {Array.} bucketCounts
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.bucketCounts = $util.emptyArray;
+ /**
+ * HistogramDataPoint explicitBounds.
+ * @member {Array.} explicitBounds
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.explicitBounds = $util.emptyArray;
+ /**
+ * HistogramDataPoint exemplars.
+ * @member {Array.} exemplars
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.exemplars = $util.emptyArray;
+ /**
+ * HistogramDataPoint flags.
+ * @member {number|null|undefined} flags
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.flags = null;
+ /**
+ * HistogramDataPoint min.
+ * @member {number|null|undefined} min
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.min = null;
+ /**
+ * HistogramDataPoint max.
+ * @member {number|null|undefined} max
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ HistogramDataPoint.prototype.max = null;
+ var $oneOfFields;
+ /**
+ * HistogramDataPoint _sum.
+ * @member {"sum"|undefined} _sum
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ Object.defineProperty(HistogramDataPoint.prototype, "_sum", {
+ get: $util.oneOfGetter($oneOfFields = ["sum"]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * HistogramDataPoint _min.
+ * @member {"min"|undefined} _min
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ Object.defineProperty(HistogramDataPoint.prototype, "_min", {
+ get: $util.oneOfGetter($oneOfFields = ["min"]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * HistogramDataPoint _max.
+ * @member {"max"|undefined} _max
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ */
+ Object.defineProperty(HistogramDataPoint.prototype, "_max", {
+ get: $util.oneOfGetter($oneOfFields = ["max"]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * Creates a new HistogramDataPoint instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IHistogramDataPoint=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.HistogramDataPoint} HistogramDataPoint instance
+ */
+ HistogramDataPoint.create = function create(properties) {
+ return new HistogramDataPoint(properties);
+ };
+ /**
+ * Encodes the specified HistogramDataPoint message. Does not implicitly {@link opentelemetry.proto.metrics.v1.HistogramDataPoint.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IHistogramDataPoint} message HistogramDataPoint message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ HistogramDataPoint.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.startTimeUnixNano != null && Object.hasOwnProperty.call(message, "startTimeUnixNano")) writer.uint32(17).fixed64(message.startTimeUnixNano);
+ if (message.timeUnixNano != null && Object.hasOwnProperty.call(message, "timeUnixNano")) writer.uint32(25).fixed64(message.timeUnixNano);
+ if (message.count != null && Object.hasOwnProperty.call(message, "count")) writer.uint32(33).fixed64(message.count);
+ if (message.sum != null && Object.hasOwnProperty.call(message, "sum")) writer.uint32(41).double(message.sum);
+ if (message.bucketCounts != null && message.bucketCounts.length) {
+ writer.uint32(50).fork();
+ for (var i = 0; i < message.bucketCounts.length; ++i) writer.fixed64(message.bucketCounts[i]);
+ writer.ldelim();
+ }
+ if (message.explicitBounds != null && message.explicitBounds.length) {
+ writer.uint32(58).fork();
+ for (var i = 0; i < message.explicitBounds.length; ++i) writer.double(message.explicitBounds[i]);
+ writer.ldelim();
+ }
+ if (message.exemplars != null && message.exemplars.length) for (var i = 0; i < message.exemplars.length; ++i) $root.opentelemetry.proto.metrics.v1.Exemplar.encode(message.exemplars[i], writer.uint32(66).fork()).ldelim();
+ if (message.attributes != null && message.attributes.length) for (var i = 0; i < message.attributes.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.attributes[i], writer.uint32(74).fork()).ldelim();
+ if (message.flags != null && Object.hasOwnProperty.call(message, "flags")) writer.uint32(80).uint32(message.flags);
+ if (message.min != null && Object.hasOwnProperty.call(message, "min")) writer.uint32(89).double(message.min);
+ if (message.max != null && Object.hasOwnProperty.call(message, "max")) writer.uint32(97).double(message.max);
+ return writer;
+ };
+ /**
+ * Encodes the specified HistogramDataPoint message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.HistogramDataPoint.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IHistogramDataPoint} message HistogramDataPoint message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ HistogramDataPoint.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a HistogramDataPoint message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.HistogramDataPoint} HistogramDataPoint
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ HistogramDataPoint.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.HistogramDataPoint();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 9:
+ if (!(message.attributes && message.attributes.length)) message.attributes = [];
+ message.attributes.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ case 2:
+ message.startTimeUnixNano = reader.fixed64();
+ break;
+ case 3:
+ message.timeUnixNano = reader.fixed64();
+ break;
+ case 4:
+ message.count = reader.fixed64();
+ break;
+ case 5:
+ message.sum = reader.double();
+ break;
+ case 6:
+ if (!(message.bucketCounts && message.bucketCounts.length)) message.bucketCounts = [];
+ if ((tag & 7) === 2) {
+ var end2 = reader.uint32() + reader.pos;
+ while (reader.pos < end2) message.bucketCounts.push(reader.fixed64());
+ } else message.bucketCounts.push(reader.fixed64());
+ break;
+ case 7:
+ if (!(message.explicitBounds && message.explicitBounds.length)) message.explicitBounds = [];
+ if ((tag & 7) === 2) {
+ var end2 = reader.uint32() + reader.pos;
+ while (reader.pos < end2) message.explicitBounds.push(reader.double());
+ } else message.explicitBounds.push(reader.double());
+ break;
+ case 8:
+ if (!(message.exemplars && message.exemplars.length)) message.exemplars = [];
+ message.exemplars.push($root.opentelemetry.proto.metrics.v1.Exemplar.decode(reader, reader.uint32()));
+ break;
+ case 10:
+ message.flags = reader.uint32();
+ break;
+ case 11:
+ message.min = reader.double();
+ break;
+ case 12:
+ message.max = reader.double();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a HistogramDataPoint message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.HistogramDataPoint} HistogramDataPoint
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ HistogramDataPoint.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a HistogramDataPoint message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ HistogramDataPoint.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ var properties = {};
+ if (message.attributes != null && message.hasOwnProperty("attributes")) {
+ if (!Array.isArray(message.attributes)) return "attributes: array expected";
+ for (var i = 0; i < message.attributes.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.attributes[i]);
+ if (error) return "attributes." + error;
+ }
+ }
+ if (message.startTimeUnixNano != null && message.hasOwnProperty("startTimeUnixNano")) {
+ if (!$util.isInteger(message.startTimeUnixNano) && !(message.startTimeUnixNano && $util.isInteger(message.startTimeUnixNano.low) && $util.isInteger(message.startTimeUnixNano.high))) return "startTimeUnixNano: integer|Long expected";
+ }
+ if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) {
+ if (!$util.isInteger(message.timeUnixNano) && !(message.timeUnixNano && $util.isInteger(message.timeUnixNano.low) && $util.isInteger(message.timeUnixNano.high))) return "timeUnixNano: integer|Long expected";
+ }
+ if (message.count != null && message.hasOwnProperty("count")) {
+ if (!$util.isInteger(message.count) && !(message.count && $util.isInteger(message.count.low) && $util.isInteger(message.count.high))) return "count: integer|Long expected";
+ }
+ if (message.sum != null && message.hasOwnProperty("sum")) {
+ properties._sum = 1;
+ if (typeof message.sum !== "number") return "sum: number expected";
+ }
+ if (message.bucketCounts != null && message.hasOwnProperty("bucketCounts")) {
+ if (!Array.isArray(message.bucketCounts)) return "bucketCounts: array expected";
+ for (var i = 0; i < message.bucketCounts.length; ++i) if (!$util.isInteger(message.bucketCounts[i]) && !(message.bucketCounts[i] && $util.isInteger(message.bucketCounts[i].low) && $util.isInteger(message.bucketCounts[i].high))) return "bucketCounts: integer|Long[] expected";
+ }
+ if (message.explicitBounds != null && message.hasOwnProperty("explicitBounds")) {
+ if (!Array.isArray(message.explicitBounds)) return "explicitBounds: array expected";
+ for (var i = 0; i < message.explicitBounds.length; ++i) if (typeof message.explicitBounds[i] !== "number") return "explicitBounds: number[] expected";
+ }
+ if (message.exemplars != null && message.hasOwnProperty("exemplars")) {
+ if (!Array.isArray(message.exemplars)) return "exemplars: array expected";
+ for (var i = 0; i < message.exemplars.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.Exemplar.verify(message.exemplars[i]);
+ if (error) return "exemplars." + error;
+ }
+ }
+ if (message.flags != null && message.hasOwnProperty("flags")) {
+ if (!$util.isInteger(message.flags)) return "flags: integer expected";
+ }
+ if (message.min != null && message.hasOwnProperty("min")) {
+ properties._min = 1;
+ if (typeof message.min !== "number") return "min: number expected";
+ }
+ if (message.max != null && message.hasOwnProperty("max")) {
+ properties._max = 1;
+ if (typeof message.max !== "number") return "max: number expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a HistogramDataPoint message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.HistogramDataPoint} HistogramDataPoint
+ */
+ HistogramDataPoint.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.HistogramDataPoint) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.HistogramDataPoint();
+ if (object.attributes) {
+ if (!Array.isArray(object.attributes)) throw TypeError(".opentelemetry.proto.metrics.v1.HistogramDataPoint.attributes: array expected");
+ message.attributes = [];
+ for (var i = 0; i < object.attributes.length; ++i) {
+ if (typeof object.attributes[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.HistogramDataPoint.attributes: object expected");
+ message.attributes[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.attributes[i]);
+ }
+ }
+ if (object.startTimeUnixNano != null) {
+ if ($util.Long) (message.startTimeUnixNano = $util.Long.fromValue(object.startTimeUnixNano)).unsigned = false;
+ else if (typeof object.startTimeUnixNano === "string") message.startTimeUnixNano = parseInt(object.startTimeUnixNano, 10);
+ else if (typeof object.startTimeUnixNano === "number") message.startTimeUnixNano = object.startTimeUnixNano;
+ else if (typeof object.startTimeUnixNano === "object") message.startTimeUnixNano = new $util.LongBits(object.startTimeUnixNano.low >>> 0, object.startTimeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.timeUnixNano != null) {
+ if ($util.Long) (message.timeUnixNano = $util.Long.fromValue(object.timeUnixNano)).unsigned = false;
+ else if (typeof object.timeUnixNano === "string") message.timeUnixNano = parseInt(object.timeUnixNano, 10);
+ else if (typeof object.timeUnixNano === "number") message.timeUnixNano = object.timeUnixNano;
+ else if (typeof object.timeUnixNano === "object") message.timeUnixNano = new $util.LongBits(object.timeUnixNano.low >>> 0, object.timeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.count != null) {
+ if ($util.Long) (message.count = $util.Long.fromValue(object.count)).unsigned = false;
+ else if (typeof object.count === "string") message.count = parseInt(object.count, 10);
+ else if (typeof object.count === "number") message.count = object.count;
+ else if (typeof object.count === "object") message.count = new $util.LongBits(object.count.low >>> 0, object.count.high >>> 0).toNumber();
+ }
+ if (object.sum != null) message.sum = Number(object.sum);
+ if (object.bucketCounts) {
+ if (!Array.isArray(object.bucketCounts)) throw TypeError(".opentelemetry.proto.metrics.v1.HistogramDataPoint.bucketCounts: array expected");
+ message.bucketCounts = [];
+ for (var i = 0; i < object.bucketCounts.length; ++i) if ($util.Long) (message.bucketCounts[i] = $util.Long.fromValue(object.bucketCounts[i])).unsigned = false;
+ else if (typeof object.bucketCounts[i] === "string") message.bucketCounts[i] = parseInt(object.bucketCounts[i], 10);
+ else if (typeof object.bucketCounts[i] === "number") message.bucketCounts[i] = object.bucketCounts[i];
+ else if (typeof object.bucketCounts[i] === "object") message.bucketCounts[i] = new $util.LongBits(object.bucketCounts[i].low >>> 0, object.bucketCounts[i].high >>> 0).toNumber();
+ }
+ if (object.explicitBounds) {
+ if (!Array.isArray(object.explicitBounds)) throw TypeError(".opentelemetry.proto.metrics.v1.HistogramDataPoint.explicitBounds: array expected");
+ message.explicitBounds = [];
+ for (var i = 0; i < object.explicitBounds.length; ++i) message.explicitBounds[i] = Number(object.explicitBounds[i]);
+ }
+ if (object.exemplars) {
+ if (!Array.isArray(object.exemplars)) throw TypeError(".opentelemetry.proto.metrics.v1.HistogramDataPoint.exemplars: array expected");
+ message.exemplars = [];
+ for (var i = 0; i < object.exemplars.length; ++i) {
+ if (typeof object.exemplars[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.HistogramDataPoint.exemplars: object expected");
+ message.exemplars[i] = $root.opentelemetry.proto.metrics.v1.Exemplar.fromObject(object.exemplars[i]);
+ }
+ }
+ if (object.flags != null) message.flags = object.flags >>> 0;
+ if (object.min != null) message.min = Number(object.min);
+ if (object.max != null) message.max = Number(object.max);
+ return message;
+ };
+ /**
+ * Creates a plain object from a HistogramDataPoint message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.HistogramDataPoint} message HistogramDataPoint
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ HistogramDataPoint.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) {
+ object.bucketCounts = [];
+ object.explicitBounds = [];
+ object.exemplars = [];
+ object.attributes = [];
+ }
+ if (options.defaults) {
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.startTimeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.startTimeUnixNano = options.longs === String ? "0" : 0;
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.timeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.timeUnixNano = options.longs === String ? "0" : 0;
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.count = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.count = options.longs === String ? "0" : 0;
+ object.flags = 0;
+ }
+ if (message.startTimeUnixNano != null && message.hasOwnProperty("startTimeUnixNano")) if (typeof message.startTimeUnixNano === "number") object.startTimeUnixNano = options.longs === String ? String(message.startTimeUnixNano) : message.startTimeUnixNano;
+ else object.startTimeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.startTimeUnixNano) : options.longs === Number ? new $util.LongBits(message.startTimeUnixNano.low >>> 0, message.startTimeUnixNano.high >>> 0).toNumber() : message.startTimeUnixNano;
+ if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) if (typeof message.timeUnixNano === "number") object.timeUnixNano = options.longs === String ? String(message.timeUnixNano) : message.timeUnixNano;
+ else object.timeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.timeUnixNano) : options.longs === Number ? new $util.LongBits(message.timeUnixNano.low >>> 0, message.timeUnixNano.high >>> 0).toNumber() : message.timeUnixNano;
+ if (message.count != null && message.hasOwnProperty("count")) if (typeof message.count === "number") object.count = options.longs === String ? String(message.count) : message.count;
+ else object.count = options.longs === String ? $util.Long.prototype.toString.call(message.count) : options.longs === Number ? new $util.LongBits(message.count.low >>> 0, message.count.high >>> 0).toNumber() : message.count;
+ if (message.sum != null && message.hasOwnProperty("sum")) {
+ object.sum = options.json && !isFinite(message.sum) ? String(message.sum) : message.sum;
+ if (options.oneofs) object._sum = "sum";
+ }
+ if (message.bucketCounts && message.bucketCounts.length) {
+ object.bucketCounts = [];
+ for (var j = 0; j < message.bucketCounts.length; ++j) if (typeof message.bucketCounts[j] === "number") object.bucketCounts[j] = options.longs === String ? String(message.bucketCounts[j]) : message.bucketCounts[j];
+ else object.bucketCounts[j] = options.longs === String ? $util.Long.prototype.toString.call(message.bucketCounts[j]) : options.longs === Number ? new $util.LongBits(message.bucketCounts[j].low >>> 0, message.bucketCounts[j].high >>> 0).toNumber() : message.bucketCounts[j];
+ }
+ if (message.explicitBounds && message.explicitBounds.length) {
+ object.explicitBounds = [];
+ for (var j = 0; j < message.explicitBounds.length; ++j) object.explicitBounds[j] = options.json && !isFinite(message.explicitBounds[j]) ? String(message.explicitBounds[j]) : message.explicitBounds[j];
+ }
+ if (message.exemplars && message.exemplars.length) {
+ object.exemplars = [];
+ for (var j = 0; j < message.exemplars.length; ++j) object.exemplars[j] = $root.opentelemetry.proto.metrics.v1.Exemplar.toObject(message.exemplars[j], options);
+ }
+ if (message.attributes && message.attributes.length) {
+ object.attributes = [];
+ for (var j = 0; j < message.attributes.length; ++j) object.attributes[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.attributes[j], options);
+ }
+ if (message.flags != null && message.hasOwnProperty("flags")) object.flags = message.flags;
+ if (message.min != null && message.hasOwnProperty("min")) {
+ object.min = options.json && !isFinite(message.min) ? String(message.min) : message.min;
+ if (options.oneofs) object._min = "min";
+ }
+ if (message.max != null && message.hasOwnProperty("max")) {
+ object.max = options.json && !isFinite(message.max) ? String(message.max) : message.max;
+ if (options.oneofs) object._max = "max";
+ }
+ return object;
+ };
+ /**
+ * Converts this HistogramDataPoint to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ HistogramDataPoint.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for HistogramDataPoint
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.HistogramDataPoint
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ HistogramDataPoint.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.HistogramDataPoint";
+ };
+ return HistogramDataPoint;
+ })();
+ v1.ExponentialHistogramDataPoint = (function() {
+ /**
+ * Properties of an ExponentialHistogramDataPoint.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @interface IExponentialHistogramDataPoint
+ * @property {Array.|null} [attributes] ExponentialHistogramDataPoint attributes
+ * @property {number|Long|null} [startTimeUnixNano] ExponentialHistogramDataPoint startTimeUnixNano
+ * @property {number|Long|null} [timeUnixNano] ExponentialHistogramDataPoint timeUnixNano
+ * @property {number|Long|null} [count] ExponentialHistogramDataPoint count
+ * @property {number|null} [sum] ExponentialHistogramDataPoint sum
+ * @property {number|null} [scale] ExponentialHistogramDataPoint scale
+ * @property {number|Long|null} [zeroCount] ExponentialHistogramDataPoint zeroCount
+ * @property {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.IBuckets|null} [positive] ExponentialHistogramDataPoint positive
+ * @property {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.IBuckets|null} [negative] ExponentialHistogramDataPoint negative
+ * @property {number|null} [flags] ExponentialHistogramDataPoint flags
+ * @property {Array.|null} [exemplars] ExponentialHistogramDataPoint exemplars
+ * @property {number|null} [min] ExponentialHistogramDataPoint min
+ * @property {number|null} [max] ExponentialHistogramDataPoint max
+ * @property {number|null} [zeroThreshold] ExponentialHistogramDataPoint zeroThreshold
+ */
+ /**
+ * Constructs a new ExponentialHistogramDataPoint.
+ * @memberof opentelemetry.proto.metrics.v1
+ * @classdesc Represents an ExponentialHistogramDataPoint.
+ * @implements IExponentialHistogramDataPoint
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.IExponentialHistogramDataPoint=} [properties] Properties to set
+ */
+ function ExponentialHistogramDataPoint(properties) {
+ this.attributes = [];
+ this.exemplars = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * ExponentialHistogramDataPoint attributes.
+ * @member {Array.} attributes
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.attributes = $util.emptyArray;
+ /**
+ * ExponentialHistogramDataPoint startTimeUnixNano.
+ * @member {number|Long|null|undefined} startTimeUnixNano
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.startTimeUnixNano = null;
+ /**
+ * ExponentialHistogramDataPoint timeUnixNano.
+ * @member {number|Long|null|undefined} timeUnixNano
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.timeUnixNano = null;
+ /**
+ * ExponentialHistogramDataPoint count.
+ * @member {number|Long|null|undefined} count
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.count = null;
+ /**
+ * ExponentialHistogramDataPoint sum.
+ * @member {number|null|undefined} sum
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.sum = null;
+ /**
+ * ExponentialHistogramDataPoint scale.
+ * @member {number|null|undefined} scale
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.scale = null;
+ /**
+ * ExponentialHistogramDataPoint zeroCount.
+ * @member {number|Long|null|undefined} zeroCount
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.zeroCount = null;
+ /**
+ * ExponentialHistogramDataPoint positive.
+ * @member {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.IBuckets|null|undefined} positive
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.positive = null;
+ /**
+ * ExponentialHistogramDataPoint negative.
+ * @member {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.IBuckets|null|undefined} negative
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.negative = null;
+ /**
+ * ExponentialHistogramDataPoint flags.
+ * @member {number|null|undefined} flags
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.flags = null;
+ /**
+ * ExponentialHistogramDataPoint exemplars.
+ * @member {Array.} exemplars
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.exemplars = $util.emptyArray;
+ /**
+ * ExponentialHistogramDataPoint min.
+ * @member {number|null|undefined} min
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.min = null;
+ /**
+ * ExponentialHistogramDataPoint max.
+ * @member {number|null|undefined} max
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.max = null;
+ /**
+ * ExponentialHistogramDataPoint zeroThreshold.
+ * @member {number|null|undefined} zeroThreshold
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ ExponentialHistogramDataPoint.prototype.zeroThreshold = null;
+ var $oneOfFields;
+ /**
+ * ExponentialHistogramDataPoint _sum.
+ * @member {"sum"|undefined} _sum
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ Object.defineProperty(ExponentialHistogramDataPoint.prototype, "_sum", {
+ get: $util.oneOfGetter($oneOfFields = ["sum"]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * ExponentialHistogramDataPoint _min.
+ * @member {"min"|undefined} _min
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ Object.defineProperty(ExponentialHistogramDataPoint.prototype, "_min", {
+ get: $util.oneOfGetter($oneOfFields = ["min"]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * ExponentialHistogramDataPoint _max.
+ * @member {"max"|undefined} _max
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ */
+ Object.defineProperty(ExponentialHistogramDataPoint.prototype, "_max", {
+ get: $util.oneOfGetter($oneOfFields = ["max"]),
+ set: $util.oneOfSetter($oneOfFields)
+ });
+ /**
+ * Creates a new ExponentialHistogramDataPoint instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IExponentialHistogramDataPoint=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint} ExponentialHistogramDataPoint instance
+ */
+ ExponentialHistogramDataPoint.create = function create(properties) {
+ return new ExponentialHistogramDataPoint(properties);
+ };
+ /**
+ * Encodes the specified ExponentialHistogramDataPoint message. Does not implicitly {@link opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IExponentialHistogramDataPoint} message ExponentialHistogramDataPoint message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExponentialHistogramDataPoint.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.attributes != null && message.attributes.length) for (var i = 0; i < message.attributes.length; ++i) $root.opentelemetry.proto.common.v1.KeyValue.encode(message.attributes[i], writer.uint32(10).fork()).ldelim();
+ if (message.startTimeUnixNano != null && Object.hasOwnProperty.call(message, "startTimeUnixNano")) writer.uint32(17).fixed64(message.startTimeUnixNano);
+ if (message.timeUnixNano != null && Object.hasOwnProperty.call(message, "timeUnixNano")) writer.uint32(25).fixed64(message.timeUnixNano);
+ if (message.count != null && Object.hasOwnProperty.call(message, "count")) writer.uint32(33).fixed64(message.count);
+ if (message.sum != null && Object.hasOwnProperty.call(message, "sum")) writer.uint32(41).double(message.sum);
+ if (message.scale != null && Object.hasOwnProperty.call(message, "scale")) writer.uint32(48).sint32(message.scale);
+ if (message.zeroCount != null && Object.hasOwnProperty.call(message, "zeroCount")) writer.uint32(57).fixed64(message.zeroCount);
+ if (message.positive != null && Object.hasOwnProperty.call(message, "positive")) $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.encode(message.positive, writer.uint32(66).fork()).ldelim();
+ if (message.negative != null && Object.hasOwnProperty.call(message, "negative")) $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.encode(message.negative, writer.uint32(74).fork()).ldelim();
+ if (message.flags != null && Object.hasOwnProperty.call(message, "flags")) writer.uint32(80).uint32(message.flags);
+ if (message.exemplars != null && message.exemplars.length) for (var i = 0; i < message.exemplars.length; ++i) $root.opentelemetry.proto.metrics.v1.Exemplar.encode(message.exemplars[i], writer.uint32(90).fork()).ldelim();
+ if (message.min != null && Object.hasOwnProperty.call(message, "min")) writer.uint32(97).double(message.min);
+ if (message.max != null && Object.hasOwnProperty.call(message, "max")) writer.uint32(105).double(message.max);
+ if (message.zeroThreshold != null && Object.hasOwnProperty.call(message, "zeroThreshold")) writer.uint32(113).double(message.zeroThreshold);
+ return writer;
+ };
+ /**
+ * Encodes the specified ExponentialHistogramDataPoint message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.IExponentialHistogramDataPoint} message ExponentialHistogramDataPoint message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ ExponentialHistogramDataPoint.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes an ExponentialHistogramDataPoint message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint} ExponentialHistogramDataPoint
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExponentialHistogramDataPoint.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ if (!(message.attributes && message.attributes.length)) message.attributes = [];
+ message.attributes.push($root.opentelemetry.proto.common.v1.KeyValue.decode(reader, reader.uint32()));
+ break;
+ case 2:
+ message.startTimeUnixNano = reader.fixed64();
+ break;
+ case 3:
+ message.timeUnixNano = reader.fixed64();
+ break;
+ case 4:
+ message.count = reader.fixed64();
+ break;
+ case 5:
+ message.sum = reader.double();
+ break;
+ case 6:
+ message.scale = reader.sint32();
+ break;
+ case 7:
+ message.zeroCount = reader.fixed64();
+ break;
+ case 8:
+ message.positive = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.decode(reader, reader.uint32());
+ break;
+ case 9:
+ message.negative = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.decode(reader, reader.uint32());
+ break;
+ case 10:
+ message.flags = reader.uint32();
+ break;
+ case 11:
+ if (!(message.exemplars && message.exemplars.length)) message.exemplars = [];
+ message.exemplars.push($root.opentelemetry.proto.metrics.v1.Exemplar.decode(reader, reader.uint32()));
+ break;
+ case 12:
+ message.min = reader.double();
+ break;
+ case 13:
+ message.max = reader.double();
+ break;
+ case 14:
+ message.zeroThreshold = reader.double();
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes an ExponentialHistogramDataPoint message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint} ExponentialHistogramDataPoint
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ ExponentialHistogramDataPoint.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies an ExponentialHistogramDataPoint message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ ExponentialHistogramDataPoint.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ var properties = {};
+ if (message.attributes != null && message.hasOwnProperty("attributes")) {
+ if (!Array.isArray(message.attributes)) return "attributes: array expected";
+ for (var i = 0; i < message.attributes.length; ++i) {
+ var error = $root.opentelemetry.proto.common.v1.KeyValue.verify(message.attributes[i]);
+ if (error) return "attributes." + error;
+ }
+ }
+ if (message.startTimeUnixNano != null && message.hasOwnProperty("startTimeUnixNano")) {
+ if (!$util.isInteger(message.startTimeUnixNano) && !(message.startTimeUnixNano && $util.isInteger(message.startTimeUnixNano.low) && $util.isInteger(message.startTimeUnixNano.high))) return "startTimeUnixNano: integer|Long expected";
+ }
+ if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) {
+ if (!$util.isInteger(message.timeUnixNano) && !(message.timeUnixNano && $util.isInteger(message.timeUnixNano.low) && $util.isInteger(message.timeUnixNano.high))) return "timeUnixNano: integer|Long expected";
+ }
+ if (message.count != null && message.hasOwnProperty("count")) {
+ if (!$util.isInteger(message.count) && !(message.count && $util.isInteger(message.count.low) && $util.isInteger(message.count.high))) return "count: integer|Long expected";
+ }
+ if (message.sum != null && message.hasOwnProperty("sum")) {
+ properties._sum = 1;
+ if (typeof message.sum !== "number") return "sum: number expected";
+ }
+ if (message.scale != null && message.hasOwnProperty("scale")) {
+ if (!$util.isInteger(message.scale)) return "scale: integer expected";
+ }
+ if (message.zeroCount != null && message.hasOwnProperty("zeroCount")) {
+ if (!$util.isInteger(message.zeroCount) && !(message.zeroCount && $util.isInteger(message.zeroCount.low) && $util.isInteger(message.zeroCount.high))) return "zeroCount: integer|Long expected";
+ }
+ if (message.positive != null && message.hasOwnProperty("positive")) {
+ var error = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.verify(message.positive);
+ if (error) return "positive." + error;
+ }
+ if (message.negative != null && message.hasOwnProperty("negative")) {
+ var error = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.verify(message.negative);
+ if (error) return "negative." + error;
+ }
+ if (message.flags != null && message.hasOwnProperty("flags")) {
+ if (!$util.isInteger(message.flags)) return "flags: integer expected";
+ }
+ if (message.exemplars != null && message.hasOwnProperty("exemplars")) {
+ if (!Array.isArray(message.exemplars)) return "exemplars: array expected";
+ for (var i = 0; i < message.exemplars.length; ++i) {
+ var error = $root.opentelemetry.proto.metrics.v1.Exemplar.verify(message.exemplars[i]);
+ if (error) return "exemplars." + error;
+ }
+ }
+ if (message.min != null && message.hasOwnProperty("min")) {
+ properties._min = 1;
+ if (typeof message.min !== "number") return "min: number expected";
+ }
+ if (message.max != null && message.hasOwnProperty("max")) {
+ properties._max = 1;
+ if (typeof message.max !== "number") return "max: number expected";
+ }
+ if (message.zeroThreshold != null && message.hasOwnProperty("zeroThreshold")) {
+ if (typeof message.zeroThreshold !== "number") return "zeroThreshold: number expected";
+ }
+ return null;
+ };
+ /**
+ * Creates an ExponentialHistogramDataPoint message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint} ExponentialHistogramDataPoint
+ */
+ ExponentialHistogramDataPoint.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint();
+ if (object.attributes) {
+ if (!Array.isArray(object.attributes)) throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.attributes: array expected");
+ message.attributes = [];
+ for (var i = 0; i < object.attributes.length; ++i) {
+ if (typeof object.attributes[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.attributes: object expected");
+ message.attributes[i] = $root.opentelemetry.proto.common.v1.KeyValue.fromObject(object.attributes[i]);
+ }
+ }
+ if (object.startTimeUnixNano != null) {
+ if ($util.Long) (message.startTimeUnixNano = $util.Long.fromValue(object.startTimeUnixNano)).unsigned = false;
+ else if (typeof object.startTimeUnixNano === "string") message.startTimeUnixNano = parseInt(object.startTimeUnixNano, 10);
+ else if (typeof object.startTimeUnixNano === "number") message.startTimeUnixNano = object.startTimeUnixNano;
+ else if (typeof object.startTimeUnixNano === "object") message.startTimeUnixNano = new $util.LongBits(object.startTimeUnixNano.low >>> 0, object.startTimeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.timeUnixNano != null) {
+ if ($util.Long) (message.timeUnixNano = $util.Long.fromValue(object.timeUnixNano)).unsigned = false;
+ else if (typeof object.timeUnixNano === "string") message.timeUnixNano = parseInt(object.timeUnixNano, 10);
+ else if (typeof object.timeUnixNano === "number") message.timeUnixNano = object.timeUnixNano;
+ else if (typeof object.timeUnixNano === "object") message.timeUnixNano = new $util.LongBits(object.timeUnixNano.low >>> 0, object.timeUnixNano.high >>> 0).toNumber();
+ }
+ if (object.count != null) {
+ if ($util.Long) (message.count = $util.Long.fromValue(object.count)).unsigned = false;
+ else if (typeof object.count === "string") message.count = parseInt(object.count, 10);
+ else if (typeof object.count === "number") message.count = object.count;
+ else if (typeof object.count === "object") message.count = new $util.LongBits(object.count.low >>> 0, object.count.high >>> 0).toNumber();
+ }
+ if (object.sum != null) message.sum = Number(object.sum);
+ if (object.scale != null) message.scale = object.scale | 0;
+ if (object.zeroCount != null) {
+ if ($util.Long) (message.zeroCount = $util.Long.fromValue(object.zeroCount)).unsigned = false;
+ else if (typeof object.zeroCount === "string") message.zeroCount = parseInt(object.zeroCount, 10);
+ else if (typeof object.zeroCount === "number") message.zeroCount = object.zeroCount;
+ else if (typeof object.zeroCount === "object") message.zeroCount = new $util.LongBits(object.zeroCount.low >>> 0, object.zeroCount.high >>> 0).toNumber();
+ }
+ if (object.positive != null) {
+ if (typeof object.positive !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.positive: object expected");
+ message.positive = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.fromObject(object.positive);
+ }
+ if (object.negative != null) {
+ if (typeof object.negative !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.negative: object expected");
+ message.negative = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.fromObject(object.negative);
+ }
+ if (object.flags != null) message.flags = object.flags >>> 0;
+ if (object.exemplars) {
+ if (!Array.isArray(object.exemplars)) throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.exemplars: array expected");
+ message.exemplars = [];
+ for (var i = 0; i < object.exemplars.length; ++i) {
+ if (typeof object.exemplars[i] !== "object") throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.exemplars: object expected");
+ message.exemplars[i] = $root.opentelemetry.proto.metrics.v1.Exemplar.fromObject(object.exemplars[i]);
+ }
+ }
+ if (object.min != null) message.min = Number(object.min);
+ if (object.max != null) message.max = Number(object.max);
+ if (object.zeroThreshold != null) message.zeroThreshold = Number(object.zeroThreshold);
+ return message;
+ };
+ /**
+ * Creates a plain object from an ExponentialHistogramDataPoint message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint} message ExponentialHistogramDataPoint
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ ExponentialHistogramDataPoint.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) {
+ object.attributes = [];
+ object.exemplars = [];
+ }
+ if (options.defaults) {
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.startTimeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.startTimeUnixNano = options.longs === String ? "0" : 0;
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.timeUnixNano = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.timeUnixNano = options.longs === String ? "0" : 0;
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.count = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.count = options.longs === String ? "0" : 0;
+ object.scale = 0;
+ if ($util.Long) {
+ var long = new $util.Long(0, 0, false);
+ object.zeroCount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+ } else object.zeroCount = options.longs === String ? "0" : 0;
+ object.positive = null;
+ object.negative = null;
+ object.flags = 0;
+ object.zeroThreshold = 0;
+ }
+ if (message.attributes && message.attributes.length) {
+ object.attributes = [];
+ for (var j = 0; j < message.attributes.length; ++j) object.attributes[j] = $root.opentelemetry.proto.common.v1.KeyValue.toObject(message.attributes[j], options);
+ }
+ if (message.startTimeUnixNano != null && message.hasOwnProperty("startTimeUnixNano")) if (typeof message.startTimeUnixNano === "number") object.startTimeUnixNano = options.longs === String ? String(message.startTimeUnixNano) : message.startTimeUnixNano;
+ else object.startTimeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.startTimeUnixNano) : options.longs === Number ? new $util.LongBits(message.startTimeUnixNano.low >>> 0, message.startTimeUnixNano.high >>> 0).toNumber() : message.startTimeUnixNano;
+ if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) if (typeof message.timeUnixNano === "number") object.timeUnixNano = options.longs === String ? String(message.timeUnixNano) : message.timeUnixNano;
+ else object.timeUnixNano = options.longs === String ? $util.Long.prototype.toString.call(message.timeUnixNano) : options.longs === Number ? new $util.LongBits(message.timeUnixNano.low >>> 0, message.timeUnixNano.high >>> 0).toNumber() : message.timeUnixNano;
+ if (message.count != null && message.hasOwnProperty("count")) if (typeof message.count === "number") object.count = options.longs === String ? String(message.count) : message.count;
+ else object.count = options.longs === String ? $util.Long.prototype.toString.call(message.count) : options.longs === Number ? new $util.LongBits(message.count.low >>> 0, message.count.high >>> 0).toNumber() : message.count;
+ if (message.sum != null && message.hasOwnProperty("sum")) {
+ object.sum = options.json && !isFinite(message.sum) ? String(message.sum) : message.sum;
+ if (options.oneofs) object._sum = "sum";
+ }
+ if (message.scale != null && message.hasOwnProperty("scale")) object.scale = message.scale;
+ if (message.zeroCount != null && message.hasOwnProperty("zeroCount")) if (typeof message.zeroCount === "number") object.zeroCount = options.longs === String ? String(message.zeroCount) : message.zeroCount;
+ else object.zeroCount = options.longs === String ? $util.Long.prototype.toString.call(message.zeroCount) : options.longs === Number ? new $util.LongBits(message.zeroCount.low >>> 0, message.zeroCount.high >>> 0).toNumber() : message.zeroCount;
+ if (message.positive != null && message.hasOwnProperty("positive")) object.positive = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.toObject(message.positive, options);
+ if (message.negative != null && message.hasOwnProperty("negative")) object.negative = $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.toObject(message.negative, options);
+ if (message.flags != null && message.hasOwnProperty("flags")) object.flags = message.flags;
+ if (message.exemplars && message.exemplars.length) {
+ object.exemplars = [];
+ for (var j = 0; j < message.exemplars.length; ++j) object.exemplars[j] = $root.opentelemetry.proto.metrics.v1.Exemplar.toObject(message.exemplars[j], options);
+ }
+ if (message.min != null && message.hasOwnProperty("min")) {
+ object.min = options.json && !isFinite(message.min) ? String(message.min) : message.min;
+ if (options.oneofs) object._min = "min";
+ }
+ if (message.max != null && message.hasOwnProperty("max")) {
+ object.max = options.json && !isFinite(message.max) ? String(message.max) : message.max;
+ if (options.oneofs) object._max = "max";
+ }
+ if (message.zeroThreshold != null && message.hasOwnProperty("zeroThreshold")) object.zeroThreshold = options.json && !isFinite(message.zeroThreshold) ? String(message.zeroThreshold) : message.zeroThreshold;
+ return object;
+ };
+ /**
+ * Converts this ExponentialHistogramDataPoint to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @instance
+ * @returns {Object.} JSON object
+ */
+ ExponentialHistogramDataPoint.prototype.toJSON = function toJSON() {
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+ };
+ /**
+ * Gets the default type url for ExponentialHistogramDataPoint
+ * @function getTypeUrl
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @static
+ * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+ * @returns {string} The default type url
+ */
+ ExponentialHistogramDataPoint.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+ if (typeUrlPrefix === void 0) typeUrlPrefix = "type.googleapis.com";
+ return typeUrlPrefix + "/opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint";
+ };
+ ExponentialHistogramDataPoint.Buckets = (function() {
+ /**
+ * Properties of a Buckets.
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @interface IBuckets
+ * @property {number|null} [offset] Buckets offset
+ * @property {Array.|null} [bucketCounts] Buckets bucketCounts
+ */
+ /**
+ * Constructs a new Buckets.
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint
+ * @classdesc Represents a Buckets.
+ * @implements IBuckets
+ * @constructor
+ * @param {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.IBuckets=} [properties] Properties to set
+ */
+ function Buckets(properties) {
+ this.bucketCounts = [];
+ if (properties) {
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+ }
+ }
+ /**
+ * Buckets offset.
+ * @member {number|null|undefined} offset
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @instance
+ */
+ Buckets.prototype.offset = null;
+ /**
+ * Buckets bucketCounts.
+ * @member {Array.} bucketCounts
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @instance
+ */
+ Buckets.prototype.bucketCounts = $util.emptyArray;
+ /**
+ * Creates a new Buckets instance using the specified properties.
+ * @function create
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.IBuckets=} [properties] Properties to set
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets} Buckets instance
+ */
+ Buckets.create = function create(properties) {
+ return new Buckets(properties);
+ };
+ /**
+ * Encodes the specified Buckets message. Does not implicitly {@link opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.verify|verify} messages.
+ * @function encode
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.IBuckets} message Buckets message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Buckets.encode = function encode(message, writer) {
+ if (!writer) writer = $Writer.create();
+ if (message.offset != null && Object.hasOwnProperty.call(message, "offset")) writer.uint32(8).sint32(message.offset);
+ if (message.bucketCounts != null && message.bucketCounts.length) {
+ writer.uint32(18).fork();
+ for (var i = 0; i < message.bucketCounts.length; ++i) writer.uint64(message.bucketCounts[i]);
+ writer.ldelim();
+ }
+ return writer;
+ };
+ /**
+ * Encodes the specified Buckets message, length delimited. Does not implicitly {@link opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.verify|verify} messages.
+ * @function encodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.IBuckets} message Buckets message or plain object to encode
+ * @param {$protobuf.Writer} [writer] Writer to encode to
+ * @returns {$protobuf.Writer} Writer
+ */
+ Buckets.encodeDelimited = function encodeDelimited(message, writer) {
+ return this.encode(message, writer).ldelim();
+ };
+ /**
+ * Decodes a Buckets message from the specified reader or buffer.
+ * @function decode
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @param {number} [length] Message length if known beforehand
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets} Buckets
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Buckets.decode = function decode(reader, length, error) {
+ if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+ var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets();
+ while (reader.pos < end) {
+ var tag = reader.uint32();
+ if (tag === error) break;
+ switch (tag >>> 3) {
+ case 1:
+ message.offset = reader.sint32();
+ break;
+ case 2:
+ if (!(message.bucketCounts && message.bucketCounts.length)) message.bucketCounts = [];
+ if ((tag & 7) === 2) {
+ var end2 = reader.uint32() + reader.pos;
+ while (reader.pos < end2) message.bucketCounts.push(reader.uint64());
+ } else message.bucketCounts.push(reader.uint64());
+ break;
+ default:
+ reader.skipType(tag & 7);
+ break;
+ }
+ }
+ return message;
+ };
+ /**
+ * Decodes a Buckets message from the specified reader or buffer, length delimited.
+ * @function decodeDelimited
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @static
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets} Buckets
+ * @throws {Error} If the payload is not a reader or valid buffer
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
+ */
+ Buckets.decodeDelimited = function decodeDelimited(reader) {
+ if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+ return this.decode(reader, reader.uint32());
+ };
+ /**
+ * Verifies a Buckets message.
+ * @function verify
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @static
+ * @param {Object.} message Plain object to verify
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
+ */
+ Buckets.verify = function verify(message) {
+ if (typeof message !== "object" || message === null) return "object expected";
+ if (message.offset != null && message.hasOwnProperty("offset")) {
+ if (!$util.isInteger(message.offset)) return "offset: integer expected";
+ }
+ if (message.bucketCounts != null && message.hasOwnProperty("bucketCounts")) {
+ if (!Array.isArray(message.bucketCounts)) return "bucketCounts: array expected";
+ for (var i = 0; i < message.bucketCounts.length; ++i) if (!$util.isInteger(message.bucketCounts[i]) && !(message.bucketCounts[i] && $util.isInteger(message.bucketCounts[i].low) && $util.isInteger(message.bucketCounts[i].high))) return "bucketCounts: integer|Long[] expected";
+ }
+ return null;
+ };
+ /**
+ * Creates a Buckets message from a plain object. Also converts values to their respective internal types.
+ * @function fromObject
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @static
+ * @param {Object.} object Plain object
+ * @returns {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets} Buckets
+ */
+ Buckets.fromObject = function fromObject(object) {
+ if (object instanceof $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets) return object;
+ var message = new $root.opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets();
+ if (object.offset != null) message.offset = object.offset | 0;
+ if (object.bucketCounts) {
+ if (!Array.isArray(object.bucketCounts)) throw TypeError(".opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets.bucketCounts: array expected");
+ message.bucketCounts = [];
+ for (var i = 0; i < object.bucketCounts.length; ++i) if ($util.Long) (message.bucketCounts[i] = $util.Long.fromValue(object.bucketCounts[i])).unsigned = true;
+ else if (typeof object.bucketCounts[i] === "string") message.bucketCounts[i] = parseInt(object.bucketCounts[i], 10);
+ else if (typeof object.bucketCounts[i] === "number") message.bucketCounts[i] = object.bucketCounts[i];
+ else if (typeof object.bucketCounts[i] === "object") message.bucketCounts[i] = new $util.LongBits(object.bucketCounts[i].low >>> 0, object.bucketCounts[i].high >>> 0).toNumber(true);
+ }
+ return message;
+ };
+ /**
+ * Creates a plain object from a Buckets message. Also converts values to other types if specified.
+ * @function toObject
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @static
+ * @param {opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets} message Buckets
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
+ * @returns {Object.} Plain object
+ */
+ Buckets.toObject = function toObject(message, options) {
+ if (!options) options = {};
+ var object = {};
+ if (options.arrays || options.defaults) object.bucketCounts = [];
+ if (options.defaults) object.offset = 0;
+ if (message.offset != null && message.hasOwnProperty("offset")) object.offset = message.offset;
+ if (message.bucketCounts && message.bucketCounts.length) {
+ object.bucketCounts = [];
+ for (var j = 0; j < message.bucketCounts.length; ++j) if (typeof message.bucketCounts[j] === "number") object.bucketCounts[j] = options.longs === String ? String(message.bucketCounts[j]) : message.bucketCounts[j];
+ else object.bucketCounts[j] = options.longs === String ? $util.Long.prototype.toString.call(message.bucketCounts[j]) : options.longs === Number ? new $util.LongBits(message.bucketCounts[j].low >>> 0, message.bucketCounts[j].high >>> 0).toNumber(true) : message.bucketCounts[j];
+ }
+ return object;
+ };
+ /**
+ * Converts this Buckets to JSON.
+ * @function toJSON
+ * @memberof opentelemetry.proto.metrics.v1.ExponentialHistogramDataPoint.Buckets
+ * @instance
+ * @returns {Object.