@use-tusk/drift-schemas 0.1.10

package/dist/span-DwoKrEhp.js

@@ -0,0 +1,778 @@
+import { Struct, Value } from "./struct-LJz5_MGH.js";
+import { Duration } from "./duration-B3fwb4jB.js";
+import { Timestamp } from "./timestamp-CN7C70ih.js";
+import { MessageType, UnknownFieldHandler, WireType, reflectionMergePartial } from "@protobuf-ts/runtime";
+
+//#region generated/ts/core/span.ts
+/**
+* Package type classification enum
+* Langauge agnostic
+*
+* @generated from protobuf enum tusk.drift.core.v1.PackageType
+*/
+let PackageType = /* @__PURE__ */ function(PackageType$1) {
+	/**
+	* @generated from protobuf enum value: PACKAGE_TYPE_UNSPECIFIED = 0;
+	*/
+	PackageType$1[PackageType$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* HTTP-based operations
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_HTTP = 1;
+	*/
+	PackageType$1[PackageType$1["HTTP"] = 1] = "HTTP";
+	/**
+	* GraphQL operations
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_GRAPHQL = 2;
+	*/
+	PackageType$1[PackageType$1["GRAPHQL"] = 2] = "GRAPHQL";
+	/**
+	* gRPC operations
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_GRPC = 3;
+	*/
+	PackageType$1[PackageType$1["GRPC"] = 3] = "GRPC";
+	/**
+	* PostgreSQL operations
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_PG = 4;
+	*/
+	PackageType$1[PackageType$1["PG"] = 4] = "PG";
+	/**
+	* MySQL operations
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_MYSQL = 5;
+	*/
+	PackageType$1[PackageType$1["MYSQL"] = 5] = "MYSQL";
+	/**
+	* MongoDB operations
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_MONGODB = 6;
+	*/
+	PackageType$1[PackageType$1["MONGODB"] = 6] = "MONGODB";
+	/**
+	* Redis caching operations
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_REDIS = 7;
+	*/
+	PackageType$1[PackageType$1["REDIS"] = 7] = "REDIS";
+	/**
+	* Apache Kafka messaging
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_KAFKA = 8;
+	*/
+	PackageType$1[PackageType$1["KAFKA"] = 8] = "KAFKA";
+	/**
+	* RabbitMQ messaging
+	*
+	* @generated from protobuf enum value: PACKAGE_TYPE_RABBITMQ = 9;
+	*/
+	PackageType$1[PackageType$1["RABBITMQ"] = 9] = "RABBITMQ";
+	return PackageType$1;
+}({});
+/**
+* OpenTelemetry-compatible span kinds
+*
+* @generated from protobuf enum tusk.drift.core.v1.SpanKind
+*/
+let SpanKind = /* @__PURE__ */ function(SpanKind$1) {
+	/**
+	* @generated from protobuf enum value: SPAN_KIND_UNSPECIFIED = 0;
+	*/
+	SpanKind$1[SpanKind$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* Internal operation
+	*
+	* @generated from protobuf enum value: SPAN_KIND_INTERNAL = 1;
+	*/
+	SpanKind$1[SpanKind$1["INTERNAL"] = 1] = "INTERNAL";
+	/**
+	* Server-side operation
+	*
+	* @generated from protobuf enum value: SPAN_KIND_SERVER = 2;
+	*/
+	SpanKind$1[SpanKind$1["SERVER"] = 2] = "SERVER";
+	/**
+	* Client-side operation
+	*
+	* @generated from protobuf enum value: SPAN_KIND_CLIENT = 3;
+	*/
+	SpanKind$1[SpanKind$1["CLIENT"] = 3] = "CLIENT";
+	/**
+	* Message producer
+	*
+	* @generated from protobuf enum value: SPAN_KIND_PRODUCER = 4;
+	*/
+	SpanKind$1[SpanKind$1["PRODUCER"] = 4] = "PRODUCER";
+	/**
+	* Message consumer
+	*
+	* @generated from protobuf enum value: SPAN_KIND_CONSUMER = 5;
+	*/
+	SpanKind$1[SpanKind$1["CONSUMER"] = 5] = "CONSUMER";
+	return SpanKind$1;
+}({});
+/**
+* @generated from protobuf enum tusk.drift.core.v1.StatusCode
+*/
+let StatusCode = /* @__PURE__ */ function(StatusCode$1) {
+	/**
+	* Default state
+	*
+	* @generated from protobuf enum value: STATUS_CODE_UNSPECIFIED = 0;
+	*/
+	StatusCode$1[StatusCode$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* Success
+	*
+	* @generated from protobuf enum value: STATUS_CODE_OK = 1;
+	*/
+	StatusCode$1[StatusCode$1["OK"] = 1] = "OK";
+	/**
+	* Error occurred
+	*
+	* @generated from protobuf enum value: STATUS_CODE_ERROR = 2;
+	*/
+	StatusCode$1[StatusCode$1["ERROR"] = 2] = "ERROR";
+	return StatusCode$1;
+}({});
+var Span$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.Span", [
+			{
+				no: 1,
+				name: "trace_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "span_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "parent_span_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 5,
+				name: "package_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 6,
+				name: "instrumentation_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 7,
+				name: "submodule_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 8,
+				name: "package_type",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.core.v1.PackageType",
+					PackageType,
+					"PACKAGE_TYPE_"
+				]
+			},
+			{
+				no: 9,
+				name: "input_value",
+				kind: "message",
+				T: () => Struct
+			},
+			{
+				no: 10,
+				name: "output_value",
+				kind: "message",
+				T: () => Struct
+			},
+			{
+				no: 11,
+				name: "input_schema",
+				kind: "message",
+				T: () => Struct
+			},
+			{
+				no: 12,
+				name: "output_schema",
+				kind: "message",
+				T: () => Struct
+			},
+			{
+				no: 13,
+				name: "input_schema_hash",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 14,
+				name: "output_schema_hash",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 15,
+				name: "input_value_hash",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 16,
+				name: "output_value_hash",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 17,
+				name: "kind",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.core.v1.SpanKind",
+					SpanKind,
+					"SPAN_KIND_"
+				]
+			},
+			{
+				no: 18,
+				name: "status",
+				kind: "message",
+				T: () => SpanStatus
+			},
+			{
+				no: 19,
+				name: "is_pre_app_start",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 20,
+				name: "timestamp",
+				kind: "message",
+				T: () => Timestamp
+			},
+			{
+				no: 21,
+				name: "duration",
+				kind: "message",
+				T: () => Duration
+			},
+			{
+				no: 22,
+				name: "is_root_span",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 23,
+				name: "metadata",
+				kind: "message",
+				T: () => Struct
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.traceId = "";
+		message.spanId = "";
+		message.parentSpanId = "";
+		message.name = "";
+		message.packageName = "";
+		message.instrumentationName = "";
+		message.submoduleName = "";
+		message.packageType = 0;
+		message.inputSchemaHash = "";
+		message.outputSchemaHash = "";
+		message.inputValueHash = "";
+		message.outputValueHash = "";
+		message.kind = 0;
+		message.isPreAppStart = false;
+		message.isRootSpan = false;
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.traceId = reader.string();
+					break;
+				case 2:
+					message.spanId = reader.string();
+					break;
+				case 3:
+					message.parentSpanId = reader.string();
+					break;
+				case 4:
+					message.name = reader.string();
+					break;
+				case 5:
+					message.packageName = reader.string();
+					break;
+				case 6:
+					message.instrumentationName = reader.string();
+					break;
+				case 7:
+					message.submoduleName = reader.string();
+					break;
+				case 8:
+					message.packageType = reader.int32();
+					break;
+				case 9:
+					message.inputValue = Struct.internalBinaryRead(reader, reader.uint32(), options, message.inputValue);
+					break;
+				case 10:
+					message.outputValue = Struct.internalBinaryRead(reader, reader.uint32(), options, message.outputValue);
+					break;
+				case 11:
+					message.inputSchema = Struct.internalBinaryRead(reader, reader.uint32(), options, message.inputSchema);
+					break;
+				case 12:
+					message.outputSchema = Struct.internalBinaryRead(reader, reader.uint32(), options, message.outputSchema);
+					break;
+				case 13:
+					message.inputSchemaHash = reader.string();
+					break;
+				case 14:
+					message.outputSchemaHash = reader.string();
+					break;
+				case 15:
+					message.inputValueHash = reader.string();
+					break;
+				case 16:
+					message.outputValueHash = reader.string();
+					break;
+				case 17:
+					message.kind = reader.int32();
+					break;
+				case 18:
+					message.status = SpanStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
+					break;
+				case 19:
+					message.isPreAppStart = reader.bool();
+					break;
+				case 20:
+					message.timestamp = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timestamp);
+					break;
+				case 21:
+					message.duration = Duration.internalBinaryRead(reader, reader.uint32(), options, message.duration);
+					break;
+				case 22:
+					message.isRootSpan = reader.bool();
+					break;
+				case 23:
+					message.metadata = Struct.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.traceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.traceId);
+		if (message.spanId !== "") writer.tag(2, WireType.LengthDelimited).string(message.spanId);
+		if (message.parentSpanId !== "") writer.tag(3, WireType.LengthDelimited).string(message.parentSpanId);
+		if (message.name !== "") writer.tag(4, WireType.LengthDelimited).string(message.name);
+		if (message.packageName !== "") writer.tag(5, WireType.LengthDelimited).string(message.packageName);
+		if (message.instrumentationName !== "") writer.tag(6, WireType.LengthDelimited).string(message.instrumentationName);
+		if (message.submoduleName !== "") writer.tag(7, WireType.LengthDelimited).string(message.submoduleName);
+		if (message.packageType !== 0) writer.tag(8, WireType.Varint).int32(message.packageType);
+		if (message.inputValue) Struct.internalBinaryWrite(message.inputValue, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+		if (message.outputValue) Struct.internalBinaryWrite(message.outputValue, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+		if (message.inputSchema) Struct.internalBinaryWrite(message.inputSchema, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+		if (message.outputSchema) Struct.internalBinaryWrite(message.outputSchema, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+		if (message.inputSchemaHash !== "") writer.tag(13, WireType.LengthDelimited).string(message.inputSchemaHash);
+		if (message.outputSchemaHash !== "") writer.tag(14, WireType.LengthDelimited).string(message.outputSchemaHash);
+		if (message.inputValueHash !== "") writer.tag(15, WireType.LengthDelimited).string(message.inputValueHash);
+		if (message.outputValueHash !== "") writer.tag(16, WireType.LengthDelimited).string(message.outputValueHash);
+		if (message.kind !== 0) writer.tag(17, WireType.Varint).int32(message.kind);
+		if (message.status) SpanStatus.internalBinaryWrite(message.status, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
+		if (message.isPreAppStart !== false) writer.tag(19, WireType.Varint).bool(message.isPreAppStart);
+		if (message.timestamp) Timestamp.internalBinaryWrite(message.timestamp, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
+		if (message.duration) Duration.internalBinaryWrite(message.duration, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
+		if (message.isRootSpan !== false) writer.tag(22, WireType.Varint).bool(message.isRootSpan);
+		if (message.metadata) Struct.internalBinaryWrite(message.metadata, writer.tag(23, WireType.LengthDelimited).fork(), options).join();
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.core.v1.Span
+*/
+const Span = new Span$Type();
+var SpanStatus$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.SpanStatus", [{
+			no: 1,
+			name: "code",
+			kind: "enum",
+			T: () => [
+				"tusk.drift.core.v1.StatusCode",
+				StatusCode,
+				"STATUS_CODE_"
+			]
+		}, {
+			no: 2,
+			name: "message",
+			kind: "scalar",
+			T: 9
+		}]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.code = 0;
+		message.message = "";
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.code = reader.int32();
+					break;
+				case 2:
+					message.message = reader.string();
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.code !== 0) writer.tag(1, WireType.Varint).int32(message.code);
+		if (message.message !== "") writer.tag(2, WireType.LengthDelimited).string(message.message);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.core.v1.SpanStatus
+*/
+const SpanStatus = new SpanStatus$Type();
+var SpanEvent$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.SpanEvent", [
+			{
+				no: 1,
+				name: "name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "timestamp",
+				kind: "message",
+				T: () => Timestamp
+			},
+			{
+				no: 3,
+				name: "attributes",
+				kind: "map",
+				K: 9,
+				V: {
+					kind: "message",
+					T: () => Value
+				}
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.name = "";
+		message.attributes = {};
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.name = reader.string();
+					break;
+				case 2:
+					message.timestamp = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timestamp);
+					break;
+				case 3:
+					this.binaryReadMap3(message.attributes, reader, options);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	binaryReadMap3(map, reader, options) {
+		let len = reader.uint32(), end = reader.pos + len, key, val;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					key = reader.string();
+					break;
+				case 2:
+					val = Value.internalBinaryRead(reader, reader.uint32(), options);
+					break;
+				default: throw new globalThis.Error("unknown map entry field for tusk.drift.core.v1.SpanEvent.attributes");
+			}
+		}
+		map[key ?? ""] = val ?? Value.create();
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.name !== "") writer.tag(1, WireType.LengthDelimited).string(message.name);
+		if (message.timestamp) Timestamp.internalBinaryWrite(message.timestamp, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+		for (let k of globalThis.Object.keys(message.attributes)) {
+			writer.tag(3, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+			writer.tag(2, WireType.LengthDelimited).fork();
+			Value.internalBinaryWrite(message.attributes[k], writer, options);
+			writer.join().join();
+		}
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.core.v1.SpanEvent
+*/
+const SpanEvent = new SpanEvent$Type();
+var SpanLink$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.SpanLink", [
+			{
+				no: 1,
+				name: "trace_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "span_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "attributes",
+				kind: "map",
+				K: 9,
+				V: {
+					kind: "message",
+					T: () => Value
+				}
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.traceId = "";
+		message.spanId = "";
+		message.attributes = {};
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.traceId = reader.string();
+					break;
+				case 2:
+					message.spanId = reader.string();
+					break;
+				case 3:
+					this.binaryReadMap3(message.attributes, reader, options);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	binaryReadMap3(map, reader, options) {
+		let len = reader.uint32(), end = reader.pos + len, key, val;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					key = reader.string();
+					break;
+				case 2:
+					val = Value.internalBinaryRead(reader, reader.uint32(), options);
+					break;
+				default: throw new globalThis.Error("unknown map entry field for tusk.drift.core.v1.SpanLink.attributes");
+			}
+		}
+		map[key ?? ""] = val ?? Value.create();
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.traceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.traceId);
+		if (message.spanId !== "") writer.tag(2, WireType.LengthDelimited).string(message.spanId);
+		for (let k of globalThis.Object.keys(message.attributes)) {
+			writer.tag(3, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+			writer.tag(2, WireType.LengthDelimited).fork();
+			Value.internalBinaryWrite(message.attributes[k], writer, options);
+			writer.join().join();
+		}
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.core.v1.SpanLink
+*/
+const SpanLink = new SpanLink$Type();
+var Trace$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.Trace", [
+			{
+				no: 1,
+				name: "trace_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "spans",
+				kind: "message",
+				repeat: 2,
+				T: () => Span
+			},
+			{
+				no: 3,
+				name: "started_at",
+				kind: "message",
+				T: () => Timestamp
+			},
+			{
+				no: 4,
+				name: "completed_at",
+				kind: "message",
+				T: () => Timestamp
+			},
+			{
+				no: 5,
+				name: "metadata",
+				kind: "map",
+				K: 9,
+				V: {
+					kind: "scalar",
+					T: 9
+				}
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.traceId = "";
+		message.spans = [];
+		message.metadata = {};
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.traceId = reader.string();
+					break;
+				case 2:
+					message.spans.push(Span.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 3:
+					message.startedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.startedAt);
+					break;
+				case 4:
+					message.completedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.completedAt);
+					break;
+				case 5:
+					this.binaryReadMap5(message.metadata, reader, options);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	binaryReadMap5(map, reader, options) {
+		let len = reader.uint32(), end = reader.pos + len, key, val;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					key = reader.string();
+					break;
+				case 2:
+					val = reader.string();
+					break;
+				default: throw new globalThis.Error("unknown map entry field for tusk.drift.core.v1.Trace.metadata");
+			}
+		}
+		map[key ?? ""] = val ?? "";
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.traceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.traceId);
+		for (let i = 0; i < message.spans.length; i++) Span.internalBinaryWrite(message.spans[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+		if (message.startedAt) Timestamp.internalBinaryWrite(message.startedAt, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		if (message.completedAt) Timestamp.internalBinaryWrite(message.completedAt, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		for (let k of globalThis.Object.keys(message.metadata)) writer.tag(5, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.metadata[k]).join();
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.core.v1.Trace
+*/
+const Trace = new Trace$Type();
+
+//#endregion
+export { PackageType, Span, SpanEvent, SpanKind, SpanLink, SpanStatus, StatusCode, Trace };
+//# sourceMappingURL=span-DwoKrEhp.js.map