@pellux/goodvibes-sdk 0.25.1 → 0.25.2

package/dist/_internal/daemon/otlp-protobuf.js

@@ -0,0 +1,968 @@
+class ProtoReader {
+    bytes;
+    offset = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    eof() {
+        return this.offset >= this.bytes.length;
+    }
+    readField() {
+        const tag = this.readVarint();
+        const fieldNumber = Number(tag >> 3n);
+        const wireType = Number(tag & 0x07n);
+        if (fieldNumber <= 0)
+            throw new Error(`Invalid protobuf field number: ${fieldNumber}`);
+        return { fieldNumber, wireType };
+    }
+    readVarint() {
+        let value = 0n;
+        let shift = 0n;
+        for (let i = 0; i < 10; i++) {
+            const byte = this.readByte();
+            value |= BigInt(byte & 0x7f) << shift;
+            if ((byte & 0x80) === 0)
+                return value;
+            shift += 7n;
+        }
+        throw new Error('Invalid protobuf varint');
+    }
+    readFixed32() {
+        this.ensure(4);
+        const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 4);
+        const value = view.getUint32(0, true);
+        this.offset += 4;
+        return value;
+    }
+    readFixed64() {
+        this.ensure(8);
+        let value = 0n;
+        for (let i = 0; i < 8; i++) {
+            value |= BigInt(this.bytes[this.offset + i]) << BigInt(i * 8);
+        }
+        this.offset += 8;
+        return value;
+    }
+    readDouble() {
+        this.ensure(8);
+        const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 8);
+        const value = view.getFloat64(0, true);
+        this.offset += 8;
+        return value;
+    }
+    readFloat() {
+        this.ensure(4);
+        const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 4);
+        const value = view.getFloat32(0, true);
+        this.offset += 4;
+        return value;
+    }
+    readLengthDelimited() {
+        const length = Number(this.readVarint());
+        if (!Number.isSafeInteger(length) || length < 0)
+            throw new Error(`Invalid protobuf length: ${length}`);
+        this.ensure(length);
+        const value = this.bytes.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return value;
+    }
+    readString() {
+        return new TextDecoder().decode(this.readLengthDelimited());
+    }
+    skip(wireType) {
+        switch (wireType) {
+            case 0:
+                this.readVarint();
+                return;
+            case 1:
+                this.ensure(8);
+                this.offset += 8;
+                return;
+            case 2: {
+                this.readLengthDelimited();
+                return;
+            }
+            case 5:
+                this.ensure(4);
+                this.offset += 4;
+                return;
+            default:
+                throw new Error(`Unsupported protobuf wire type: ${wireType}`);
+        }
+    }
+    readByte() {
+        this.ensure(1);
+        return this.bytes[this.offset++];
+    }
+    ensure(length) {
+        if (this.offset + length > this.bytes.length) {
+            throw new Error('Truncated protobuf payload');
+        }
+    }
+}
+function readMessage(reader, wireType, decode) {
+    if (wireType !== 2) {
+        reader.skip(wireType);
+        return undefined;
+    }
+    return decode(reader.readLengthDelimited());
+}
+function readString(reader, wireType) {
+    if (wireType !== 2) {
+        reader.skip(wireType);
+        return undefined;
+    }
+    return reader.readString();
+}
+function readBytes(reader, wireType) {
+    if (wireType !== 2) {
+        reader.skip(wireType);
+        return undefined;
+    }
+    return reader.readLengthDelimited();
+}
+function readBool(reader, wireType) {
+    if (wireType !== 0) {
+        reader.skip(wireType);
+        return undefined;
+    }
+    return reader.readVarint() !== 0n;
+}
+function readNumeric(reader, wireType) {
+    if (wireType === 0)
+        return Number(reader.readVarint());
+    if (wireType === 1)
+        return Number(reader.readFixed64());
+    if (wireType === 5)
+        return reader.readFixed32();
+    reader.skip(wireType);
+    return undefined;
+}
+function readFloating(reader, wireType) {
+    if (wireType === 1)
+        return reader.readDouble();
+    if (wireType === 5)
+        return reader.readFloat();
+    reader.skip(wireType);
+    return undefined;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function bytesToBase64(bytes) {
+    return Buffer.from(bytes).toString('base64');
+}
+function readKeyValueArray(target, reader, wireType) {
+    const entry = readMessage(reader, wireType, decodeKeyValue);
+    if (!entry)
+        return;
+    const current = Array.isArray(target['attributes']) ? target['attributes'] : [];
+    current.push(entry);
+    target['attributes'] = current;
+}
+function decodeKeyValue(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = {};
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['key'] = value;
+                break;
+            }
+            case 2: {
+                const value = readMessage(reader, wireType, decodeAnyValue);
+                if (value)
+                    out['value'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeAnyValue(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = {};
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['stringValue'] = value;
+                break;
+            }
+            case 2: {
+                const value = readBool(reader, wireType);
+                if (value !== undefined)
+                    out['boolValue'] = value;
+                break;
+            }
+            case 3: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['intValue'] = String(Math.trunc(value));
+                break;
+            }
+            case 4: {
+                const value = readFloating(reader, wireType);
+                if (value !== undefined)
+                    out['doubleValue'] = value;
+                break;
+            }
+            case 5: {
+                const value = readMessage(reader, wireType, decodeArrayValue);
+                if (value)
+                    out['arrayValue'] = value;
+                break;
+            }
+            case 6: {
+                const value = readMessage(reader, wireType, decodeKeyValueList);
+                if (value)
+                    out['kvlistValue'] = value;
+                break;
+            }
+            case 7: {
+                const value = readBytes(reader, wireType);
+                if (value)
+                    out['bytesValue'] = bytesToBase64(value);
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeArrayValue(bytes) {
+    const reader = new ProtoReader(bytes);
+    const values = [];
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        if (fieldNumber === 1) {
+            const value = readMessage(reader, wireType, decodeAnyValue);
+            if (value)
+                values.push(value);
+        }
+        else {
+            reader.skip(wireType);
+        }
+    }
+    return { values };
+}
+function decodeKeyValueList(bytes) {
+    const reader = new ProtoReader(bytes);
+    const values = [];
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        if (fieldNumber === 1) {
+            const value = readMessage(reader, wireType, decodeKeyValue);
+            if (value)
+                values.push(value);
+        }
+        else {
+            reader.skip(wireType);
+        }
+    }
+    return { values };
+}
+function decodeResource(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { attributes: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1:
+                readKeyValueArray(out, reader, wireType);
+                break;
+            case 2: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['droppedAttributesCount'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeScope(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { attributes: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['name'] = value;
+                break;
+            }
+            case 2: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['version'] = value;
+                break;
+            }
+            case 3:
+                readKeyValueArray(out, reader, wireType);
+                break;
+            case 4: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['droppedAttributesCount'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeExportTraceServiceRequest(bytes) {
+    const reader = new ProtoReader(bytes);
+    const resourceSpans = [];
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        if (fieldNumber === 1) {
+            const value = readMessage(reader, wireType, decodeResourceSpans);
+            if (value)
+                resourceSpans.push(value);
+        }
+        else {
+            reader.skip(wireType);
+        }
+    }
+    return { resourceSpans };
+}
+function decodeResourceSpans(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { scopeSpans: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readMessage(reader, wireType, decodeResource);
+                if (value)
+                    out['resource'] = value;
+                break;
+            }
+            case 2: {
+                const value = readMessage(reader, wireType, decodeScopeSpans);
+                if (value)
+                    out['scopeSpans'].push(value);
+                break;
+            }
+            case 3: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['schemaUrl'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeScopeSpans(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { spans: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readMessage(reader, wireType, decodeScope);
+                if (value)
+                    out['scope'] = value;
+                break;
+            }
+            case 2: {
+                const value = readMessage(reader, wireType, decodeSpan);
+                if (value)
+                    out['spans'].push(value);
+                break;
+            }
+            case 3: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['schemaUrl'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeSpan(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { attributes: [], events: [], links: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readBytes(reader, wireType);
+                if (value)
+                    out['traceId'] = bytesToHex(value);
+                break;
+            }
+            case 2: {
+                const value = readBytes(reader, wireType);
+                if (value)
+                    out['spanId'] = bytesToHex(value);
+                break;
+            }
+            case 3: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['traceState'] = value;
+                break;
+            }
+            case 4: {
+                const value = readBytes(reader, wireType);
+                if (value)
+                    out['parentSpanId'] = bytesToHex(value);
+                break;
+            }
+            case 5: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['name'] = value;
+                break;
+            }
+            case 6: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['kind'] = value;
+                break;
+            }
+            case 7: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['startTimeUnixNano'] = value;
+                break;
+            }
+            case 8: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['endTimeUnixNano'] = value;
+                break;
+            }
+            case 9:
+                readKeyValueArray(out, reader, wireType);
+                break;
+            case 10:
+            case 12:
+            case 14:
+            case 16: {
+                const key = fieldNumber === 10
+                    ? 'droppedAttributesCount'
+                    : fieldNumber === 12
+                        ? 'droppedEventsCount'
+                        : fieldNumber === 14
+                            ? 'droppedLinksCount'
+                            : 'flags';
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out[key] = value;
+                break;
+            }
+            case 11: {
+                const value = readMessage(reader, wireType, decodeSpanEvent);
+                if (value)
+                    out['events'].push(value);
+                break;
+            }
+            case 13: {
+                const value = readMessage(reader, wireType, decodeSpanLink);
+                if (value)
+                    out['links'].push(value);
+                break;
+            }
+            case 15: {
+                const value = readMessage(reader, wireType, decodeSpanStatus);
+                if (value)
+                    out['status'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeSpanEvent(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { attributes: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['timeUnixNano'] = value;
+                break;
+            }
+            case 2: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['name'] = value;
+                break;
+            }
+            case 3:
+                readKeyValueArray(out, reader, wireType);
+                break;
+            case 4: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['droppedAttributesCount'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeSpanLink(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { attributes: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readBytes(reader, wireType);
+                if (value)
+                    out['traceId'] = bytesToHex(value);
+                break;
+            }
+            case 2: {
+                const value = readBytes(reader, wireType);
+                if (value)
+                    out['spanId'] = bytesToHex(value);
+                break;
+            }
+            case 3: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['traceState'] = value;
+                break;
+            }
+            case 4:
+                readKeyValueArray(out, reader, wireType);
+                break;
+            case 5: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['droppedAttributesCount'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeSpanStatus(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = {};
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['message'] = value;
+                break;
+            }
+            case 2: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['code'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeExportLogsServiceRequest(bytes) {
+    const reader = new ProtoReader(bytes);
+    const resourceLogs = [];
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        if (fieldNumber === 1) {
+            const value = readMessage(reader, wireType, decodeResourceLogs);
+            if (value)
+                resourceLogs.push(value);
+        }
+        else {
+            reader.skip(wireType);
+        }
+    }
+    return { resourceLogs };
+}
+function decodeResourceLogs(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { scopeLogs: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readMessage(reader, wireType, decodeResource);
+                if (value)
+                    out['resource'] = value;
+                break;
+            }
+            case 2: {
+                const value = readMessage(reader, wireType, decodeScopeLogs);
+                if (value)
+                    out['scopeLogs'].push(value);
+                break;
+            }
+            case 3: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['schemaUrl'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeScopeLogs(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { logRecords: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readMessage(reader, wireType, decodeScope);
+                if (value)
+                    out['scope'] = value;
+                break;
+            }
+            case 2: {
+                const value = readMessage(reader, wireType, decodeLogRecord);
+                if (value)
+                    out['logRecords'].push(value);
+                break;
+            }
+            case 3: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['schemaUrl'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeLogRecord(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { attributes: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1:
+            case 11: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out[fieldNumber === 1 ? 'timeUnixNano' : 'observedTimeUnixNano'] = value;
+                break;
+            }
+            case 2:
+            case 7:
+            case 8: {
+                const key = fieldNumber === 2 ? 'severityNumber' : fieldNumber === 7 ? 'droppedAttributesCount' : 'flags';
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out[key] = value;
+                break;
+            }
+            case 3:
+            case 12: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out[fieldNumber === 3 ? 'severityText' : 'eventName'] = value;
+                break;
+            }
+            case 5: {
+                const value = readMessage(reader, wireType, decodeAnyValue);
+                if (value)
+                    out['body'] = value;
+                break;
+            }
+            case 6:
+                readKeyValueArray(out, reader, wireType);
+                break;
+            case 9:
+            case 10: {
+                const value = readBytes(reader, wireType);
+                if (value)
+                    out[fieldNumber === 9 ? 'traceId' : 'spanId'] = bytesToHex(value);
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeExportMetricsServiceRequest(bytes) {
+    const reader = new ProtoReader(bytes);
+    const resourceMetrics = [];
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        if (fieldNumber === 1) {
+            const value = readMessage(reader, wireType, decodeResourceMetrics);
+            if (value)
+                resourceMetrics.push(value);
+        }
+        else {
+            reader.skip(wireType);
+        }
+    }
+    return { resourceMetrics };
+}
+function decodeResourceMetrics(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { scopeMetrics: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readMessage(reader, wireType, decodeResource);
+                if (value)
+                    out['resource'] = value;
+                break;
+            }
+            case 2: {
+                const value = readMessage(reader, wireType, decodeScopeMetrics);
+                if (value)
+                    out['scopeMetrics'].push(value);
+                break;
+            }
+            case 3: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['schemaUrl'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeScopeMetrics(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { metrics: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1: {
+                const value = readMessage(reader, wireType, decodeScope);
+                if (value)
+                    out['scope'] = value;
+                break;
+            }
+            case 2: {
+                const value = readMessage(reader, wireType, decodeMetric);
+                if (value)
+                    out['metrics'].push(value);
+                break;
+            }
+            case 3: {
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out['schemaUrl'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeMetric(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = {};
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 1:
+            case 2:
+            case 3: {
+                const key = fieldNumber === 1 ? 'name' : fieldNumber === 2 ? 'description' : 'unit';
+                const value = readString(reader, wireType);
+                if (value !== undefined)
+                    out[key] = value;
+                break;
+            }
+            case 5: {
+                const value = readMessage(reader, wireType, decodeGauge);
+                if (value)
+                    out['gauge'] = value;
+                break;
+            }
+            case 7: {
+                const value = readMessage(reader, wireType, decodeSum);
+                if (value)
+                    out['sum'] = value;
+                break;
+            }
+            case 9: {
+                const value = readMessage(reader, wireType, decodeHistogram);
+                if (value)
+                    out['histogram'] = value;
+                break;
+            }
+            case 10: {
+                const value = readMessage(reader, wireType, decodeHistogram);
+                if (value)
+                    out['exponentialHistogram'] = value;
+                break;
+            }
+            case 11: {
+                const value = readMessage(reader, wireType, decodeSummary);
+                if (value)
+                    out['summary'] = value;
+                break;
+            }
+            case 12:
+                readKeyValueArray(out, reader, wireType);
+                break;
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeGauge(bytes) {
+    return decodeMetricPoints(bytes, decodeNumberDataPoint, false);
+}
+function decodeSum(bytes) {
+    return decodeMetricPoints(bytes, decodeNumberDataPoint, true);
+}
+function decodeHistogram(bytes) {
+    return decodeMetricPoints(bytes, decodeGenericDataPoint, true);
+}
+function decodeSummary(bytes) {
+    return decodeMetricPoints(bytes, decodeGenericDataPoint, false);
+}
+function decodeMetricPoints(bytes, decodeDataPoint, hasAggregationTemporality) {
+    const reader = new ProtoReader(bytes);
+    const out = { dataPoints: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        if (fieldNumber === 1) {
+            const value = readMessage(reader, wireType, decodeDataPoint);
+            if (value)
+                out['dataPoints'].push(value);
+        }
+        else if (hasAggregationTemporality && fieldNumber === 2) {
+            const value = readNumeric(reader, wireType);
+            if (value !== undefined)
+                out['aggregationTemporality'] = value;
+        }
+        else if (fieldNumber === 3) {
+            const value = readBool(reader, wireType);
+            if (value !== undefined)
+                out['isMonotonic'] = value;
+        }
+        else {
+            reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeNumberDataPoint(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { attributes: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        switch (fieldNumber) {
+            case 2:
+            case 3: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out[fieldNumber === 2 ? 'startTimeUnixNano' : 'timeUnixNano'] = value;
+                break;
+            }
+            case 4: {
+                const value = readFloating(reader, wireType);
+                if (value !== undefined)
+                    out['asDouble'] = value;
+                break;
+            }
+            case 6: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['asInt'] = String(Math.trunc(value));
+                break;
+            }
+            case 7:
+                readKeyValueArray(out, reader, wireType);
+                break;
+            case 8: {
+                const value = readNumeric(reader, wireType);
+                if (value !== undefined)
+                    out['flags'] = value;
+                break;
+            }
+            default:
+                reader.skip(wireType);
+        }
+    }
+    return out;
+}
+function decodeGenericDataPoint(bytes) {
+    const reader = new ProtoReader(bytes);
+    const out = { attributes: [] };
+    while (!reader.eof()) {
+        const { fieldNumber, wireType } = reader.readField();
+        if (fieldNumber === 2 || fieldNumber === 3 || fieldNumber === 4 || fieldNumber === 5 || fieldNumber === 10 || fieldNumber === 11 || fieldNumber === 12) {
+            const value = fieldNumber === 5 || fieldNumber === 11 || fieldNumber === 12
+                ? readFloating(reader, wireType)
+                : readNumeric(reader, wireType);
+            if (value !== undefined) {
+                out[fieldNumber === 2 ? 'startTimeUnixNano'
+                    : fieldNumber === 3 ? 'timeUnixNano'
+                        : fieldNumber === 4 ? 'count'
+                            : fieldNumber === 5 ? 'sum'
+                                : fieldNumber === 10 ? 'flags'
+                                    : fieldNumber === 11 ? 'min'
+                                        : 'max'] = value;
+            }
+        }
+        else if (fieldNumber === 9) {
+            readKeyValueArray(out, reader, wireType);
+        }
+        else {
+            reader.skip(wireType);
+        }
+    }
+    return out;
+}
+export function decodeOtlpProtobuf(kind, bytes) {
+    switch (kind) {
+        case 'logs':
+            return decodeExportLogsServiceRequest(bytes);
+        case 'traces':
+            return decodeExportTraceServiceRequest(bytes);
+        case 'metrics':
+            return decodeExportMetricsServiceRequest(bytes);
+    }
+}