@use-tusk/drift-schemas 0.1.32 → 0.1.34

package/dist/query/span_query_helpers.js

@@ -0,0 +1,2146 @@
+import { MessageType, PbLong, UnknownFieldHandler, WireType, isJsonObject, reflectionMergePartial, typeofJsonValue } from "@protobuf-ts/runtime";
+
+//#region generated/ts/google/protobuf/struct.ts
+/**
+* `NullValue` is a singleton enumeration to represent the null value for the
+* `Value` type union.
+*
+* The JSON representation for `NullValue` is JSON `null`.
+*
+* @generated from protobuf enum google.protobuf.NullValue
+*/
+let NullValue = /* @__PURE__ */ function(NullValue$1) {
+	/**
+	* Null value.
+	*
+	* @generated from protobuf enum value: NULL_VALUE = 0;
+	*/
+	NullValue$1[NullValue$1["NULL_VALUE"] = 0] = "NULL_VALUE";
+	return NullValue$1;
+}({});
+var Struct$Type = class extends MessageType {
+	constructor() {
+		super("google.protobuf.Struct", [{
+			no: 1,
+			name: "fields",
+			kind: "map",
+			K: 9,
+			V: {
+				kind: "message",
+				T: () => Value
+			}
+		}]);
+	}
+	/**
+	* Encode `Struct` to JSON object.
+	*/
+	internalJsonWrite(message, options) {
+		let json = {};
+		for (let [k, v] of Object.entries(message.fields)) json[k] = Value.toJson(v);
+		return json;
+	}
+	/**
+	* Decode `Struct` from JSON object.
+	*/
+	internalJsonRead(json, options, target) {
+		if (!isJsonObject(json)) throw new globalThis.Error("Unable to parse message " + this.typeName + " from JSON " + typeofJsonValue(json) + ".");
+		if (!target) target = this.create();
+		for (let [k, v] of globalThis.Object.entries(json)) target.fields[k] = Value.fromJson(v);
+		return target;
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.fields = {};
+		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:
+					this.binaryReadMap1(message.fields, 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;
+	}
+	binaryReadMap1(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 google.protobuf.Struct.fields");
+			}
+		}
+		map[key ?? ""] = val ?? Value.create();
+	}
+	internalBinaryWrite(message, writer, options) {
+		for (let k of globalThis.Object.keys(message.fields)) {
+			writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+			writer.tag(2, WireType.LengthDelimited).fork();
+			Value.internalBinaryWrite(message.fields[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 google.protobuf.Struct
+*/
+const Struct = new Struct$Type();
+var Value$Type = class extends MessageType {
+	constructor() {
+		super("google.protobuf.Value", [
+			{
+				no: 1,
+				name: "null_value",
+				kind: "enum",
+				oneof: "kind",
+				T: () => ["google.protobuf.NullValue", NullValue]
+			},
+			{
+				no: 2,
+				name: "number_value",
+				kind: "scalar",
+				oneof: "kind",
+				T: 1
+			},
+			{
+				no: 3,
+				name: "string_value",
+				kind: "scalar",
+				oneof: "kind",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "bool_value",
+				kind: "scalar",
+				oneof: "kind",
+				T: 8
+			},
+			{
+				no: 5,
+				name: "struct_value",
+				kind: "message",
+				oneof: "kind",
+				T: () => Struct
+			},
+			{
+				no: 6,
+				name: "list_value",
+				kind: "message",
+				oneof: "kind",
+				T: () => ListValue
+			}
+		]);
+	}
+	/**
+	* Encode `Value` to JSON value.
+	*/
+	internalJsonWrite(message, options) {
+		if (message.kind.oneofKind === void 0) throw new globalThis.Error();
+		switch (message.kind.oneofKind) {
+			case void 0: throw new globalThis.Error();
+			case "boolValue": return message.kind.boolValue;
+			case "nullValue": return null;
+			case "numberValue":
+				let numberValue = message.kind.numberValue;
+				if (typeof numberValue == "number" && !Number.isFinite(numberValue)) throw new globalThis.Error();
+				return numberValue;
+			case "stringValue": return message.kind.stringValue;
+			case "listValue":
+				let listValueField = this.fields.find((f) => f.no === 6);
+				if (listValueField?.kind !== "message") throw new globalThis.Error();
+				return listValueField.T().toJson(message.kind.listValue);
+			case "structValue":
+				let structValueField = this.fields.find((f) => f.no === 5);
+				if (structValueField?.kind !== "message") throw new globalThis.Error();
+				return structValueField.T().toJson(message.kind.structValue);
+		}
+	}
+	/**
+	* Decode `Value` from JSON value.
+	*/
+	internalJsonRead(json, options, target) {
+		if (!target) target = this.create();
+		switch (typeof json) {
+			case "number":
+				target.kind = {
+					oneofKind: "numberValue",
+					numberValue: json
+				};
+				break;
+			case "string":
+				target.kind = {
+					oneofKind: "stringValue",
+					stringValue: json
+				};
+				break;
+			case "boolean":
+				target.kind = {
+					oneofKind: "boolValue",
+					boolValue: json
+				};
+				break;
+			case "object":
+				if (json === null) target.kind = {
+					oneofKind: "nullValue",
+					nullValue: NullValue.NULL_VALUE
+				};
+				else if (globalThis.Array.isArray(json)) target.kind = {
+					oneofKind: "listValue",
+					listValue: ListValue.fromJson(json)
+				};
+				else target.kind = {
+					oneofKind: "structValue",
+					structValue: Struct.fromJson(json)
+				};
+				break;
+			default: throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
+		}
+		return target;
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.kind = { oneofKind: void 0 };
+		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.kind = {
+						oneofKind: "nullValue",
+						nullValue: reader.int32()
+					};
+					break;
+				case 2:
+					message.kind = {
+						oneofKind: "numberValue",
+						numberValue: reader.double()
+					};
+					break;
+				case 3:
+					message.kind = {
+						oneofKind: "stringValue",
+						stringValue: reader.string()
+					};
+					break;
+				case 4:
+					message.kind = {
+						oneofKind: "boolValue",
+						boolValue: reader.bool()
+					};
+					break;
+				case 5:
+					message.kind = {
+						oneofKind: "structValue",
+						structValue: Struct.internalBinaryRead(reader, reader.uint32(), options, message.kind.structValue)
+					};
+					break;
+				case 6:
+					message.kind = {
+						oneofKind: "listValue",
+						listValue: ListValue.internalBinaryRead(reader, reader.uint32(), options, message.kind.listValue)
+					};
+					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.kind.oneofKind === "nullValue") writer.tag(1, WireType.Varint).int32(message.kind.nullValue);
+		if (message.kind.oneofKind === "numberValue") writer.tag(2, WireType.Bit64).double(message.kind.numberValue);
+		if (message.kind.oneofKind === "stringValue") writer.tag(3, WireType.LengthDelimited).string(message.kind.stringValue);
+		if (message.kind.oneofKind === "boolValue") writer.tag(4, WireType.Varint).bool(message.kind.boolValue);
+		if (message.kind.oneofKind === "structValue") Struct.internalBinaryWrite(message.kind.structValue, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+		if (message.kind.oneofKind === "listValue") ListValue.internalBinaryWrite(message.kind.listValue, writer.tag(6, 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 google.protobuf.Value
+*/
+const Value = new Value$Type();
+var ListValue$Type = class extends MessageType {
+	constructor() {
+		super("google.protobuf.ListValue", [{
+			no: 1,
+			name: "values",
+			kind: "message",
+			repeat: 2,
+			T: () => Value
+		}]);
+	}
+	/**
+	* Encode `ListValue` to JSON array.
+	*/
+	internalJsonWrite(message, options) {
+		return message.values.map((v) => Value.toJson(v));
+	}
+	/**
+	* Decode `ListValue` from JSON array.
+	*/
+	internalJsonRead(json, options, target) {
+		if (!globalThis.Array.isArray(json)) throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
+		if (!target) target = this.create();
+		let values = json.map((v) => Value.fromJson(v));
+		target.values.push(...values);
+		return target;
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.values = [];
+		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.values.push(Value.internalBinaryRead(reader, reader.uint32(), 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;
+	}
+	internalBinaryWrite(message, writer, options) {
+		for (let i = 0; i < message.values.length; i++) Value.internalBinaryWrite(message.values[i], writer.tag(1, 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 google.protobuf.ListValue
+*/
+const ListValue = new ListValue$Type();
+
+//#endregion
+//#region generated/ts/google/protobuf/timestamp.ts
+var Timestamp$Type = class extends MessageType {
+	constructor() {
+		super("google.protobuf.Timestamp", [{
+			no: 1,
+			name: "seconds",
+			kind: "scalar",
+			T: 3,
+			L: 0
+		}, {
+			no: 2,
+			name: "nanos",
+			kind: "scalar",
+			T: 5
+		}]);
+	}
+	/**
+	* Creates a new `Timestamp` for the current time.
+	*/
+	now() {
+		const msg = this.create();
+		const ms = Date.now();
+		msg.seconds = PbLong.from(Math.floor(ms / 1e3)).toBigInt();
+		msg.nanos = ms % 1e3 * 1e6;
+		return msg;
+	}
+	/**
+	* Converts a `Timestamp` to a JavaScript Date.
+	*/
+	toDate(message) {
+		return new Date(PbLong.from(message.seconds).toNumber() * 1e3 + Math.ceil(message.nanos / 1e6));
+	}
+	/**
+	* Converts a JavaScript Date to a `Timestamp`.
+	*/
+	fromDate(date) {
+		const msg = this.create();
+		const ms = date.getTime();
+		msg.seconds = PbLong.from(Math.floor(ms / 1e3)).toBigInt();
+		msg.nanos = (ms % 1e3 + (ms < 0 && ms % 1e3 !== 0 ? 1e3 : 0)) * 1e6;
+		return msg;
+	}
+	/**
+	* In JSON format, the `Timestamp` type is encoded as a string
+	* in the RFC 3339 format.
+	*/
+	internalJsonWrite(message, options) {
+		let ms = PbLong.from(message.seconds).toNumber() * 1e3;
+		if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
+		if (message.nanos < 0) throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative.");
+		let z = "Z";
+		if (message.nanos > 0) {
+			let nanosStr = (message.nanos + 1e9).toString().substring(1);
+			if (nanosStr.substring(3) === "000000") z = "." + nanosStr.substring(0, 3) + "Z";
+			else if (nanosStr.substring(6) === "000") z = "." + nanosStr.substring(0, 6) + "Z";
+			else z = "." + nanosStr + "Z";
+		}
+		return new Date(ms).toISOString().replace(".000Z", z);
+	}
+	/**
+	* In JSON format, the `Timestamp` type is encoded as a string
+	* in the RFC 3339 format.
+	*/
+	internalJsonRead(json, options, target) {
+		if (typeof json !== "string") throw new Error("Unable to parse Timestamp from JSON " + typeofJsonValue(json) + ".");
+		let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+		if (!matches) throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
+		let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
+		if (Number.isNaN(ms)) throw new Error("Unable to parse Timestamp from JSON. Invalid value.");
+		if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
+		if (!target) target = this.create();
+		target.seconds = PbLong.from(ms / 1e3).toBigInt();
+		target.nanos = 0;
+		if (matches[7]) target.nanos = parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1e9;
+		return target;
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.seconds = 0n;
+		message.nanos = 0;
+		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.seconds = reader.int64().toBigInt();
+					break;
+				case 2:
+					message.nanos = reader.int32();
+					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.seconds !== 0n) writer.tag(1, WireType.Varint).int64(message.seconds);
+		if (message.nanos !== 0) writer.tag(2, WireType.Varint).int32(message.nanos);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message google.protobuf.Timestamp
+*/
+const Timestamp = new Timestamp$Type();
+
+//#endregion
+//#region generated/ts/query/span_query.ts
+/**
+* Selectable fields when fetching spans by ID.
+*
+* @generated from protobuf enum tusk.drift.query.v1.SelectableSpanField
+*/
+let SelectableSpanField = /* @__PURE__ */ function(SelectableSpanField$1) {
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_UNSPECIFIED = 0;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_ID = 1;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["ID"] = 1] = "ID";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_SPAN_ID = 2;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["SPAN_ID"] = 2] = "SPAN_ID";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_TRACE_ID = 3;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["TRACE_ID"] = 3] = "TRACE_ID";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_PARENT_SPAN_ID = 4;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["PARENT_SPAN_ID"] = 4] = "PARENT_SPAN_ID";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_NAME = 5;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["NAME"] = 5] = "NAME";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_KIND = 6;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["KIND"] = 6] = "KIND";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_STATUS = 7;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["STATUS"] = 7] = "STATUS";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_TIMESTAMP = 8;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["TIMESTAMP"] = 8] = "TIMESTAMP";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_DURATION = 9;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["DURATION"] = 9] = "DURATION";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_IS_ROOT_SPAN = 10;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["IS_ROOT_SPAN"] = 10] = "IS_ROOT_SPAN";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_METADATA = 11;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["METADATA"] = 11] = "METADATA";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_PACKAGE_NAME = 12;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["PACKAGE_NAME"] = 12] = "PACKAGE_NAME";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_INSTRUMENTATION_NAME = 13;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["INSTRUMENTATION_NAME"] = 13] = "INSTRUMENTATION_NAME";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_INPUT_VALUE = 14;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["INPUT_VALUE"] = 14] = "INPUT_VALUE";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_OUTPUT_VALUE = 15;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["OUTPUT_VALUE"] = 15] = "OUTPUT_VALUE";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_INPUT_SCHEMA = 16;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["INPUT_SCHEMA"] = 16] = "INPUT_SCHEMA";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_OUTPUT_SCHEMA = 17;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["OUTPUT_SCHEMA"] = 17] = "OUTPUT_SCHEMA";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_ENVIRONMENT = 18;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["ENVIRONMENT"] = 18] = "ENVIRONMENT";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_CREATED_AT = 19;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["CREATED_AT"] = 19] = "CREATED_AT";
+	/**
+	* @generated from protobuf enum value: SELECTABLE_SPAN_FIELD_UPDATED_AT = 20;
+	*/
+	SelectableSpanField$1[SelectableSpanField$1["UPDATED_AT"] = 20] = "UPDATED_AT";
+	return SelectableSpanField$1;
+}({});
+/**
+* Optional cast applied before comparisons.
+*
+* @generated from protobuf enum tusk.drift.query.v1.CastType
+*/
+let CastType = /* @__PURE__ */ function(CastType$1) {
+	/**
+	* @generated from protobuf enum value: CAST_TYPE_UNSPECIFIED = 0;
+	*/
+	CastType$1[CastType$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: CAST_TYPE_TEXT = 1;
+	*/
+	CastType$1[CastType$1["TEXT"] = 1] = "TEXT";
+	/**
+	* @generated from protobuf enum value: CAST_TYPE_INT = 2;
+	*/
+	CastType$1[CastType$1["INT"] = 2] = "INT";
+	/**
+	* @generated from protobuf enum value: CAST_TYPE_FLOAT = 3;
+	*/
+	CastType$1[CastType$1["FLOAT"] = 3] = "FLOAT";
+	/**
+	* @generated from protobuf enum value: CAST_TYPE_BOOLEAN = 4;
+	*/
+	CastType$1[CastType$1["BOOLEAN"] = 4] = "BOOLEAN";
+	return CastType$1;
+}({});
+/**
+* Optional decoding applied before an additional JSONPath extraction.
+*
+* @generated from protobuf enum tusk.drift.query.v1.DecodeStrategy
+*/
+let DecodeStrategy = /* @__PURE__ */ function(DecodeStrategy$1) {
+	/**
+	* @generated from protobuf enum value: DECODE_STRATEGY_UNSPECIFIED = 0;
+	*/
+	DecodeStrategy$1[DecodeStrategy$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: DECODE_STRATEGY_BASE64 = 1;
+	*/
+	DecodeStrategy$1[DecodeStrategy$1["BASE64"] = 1] = "BASE64";
+	return DecodeStrategy$1;
+}({});
+/**
+* @generated from protobuf enum tusk.drift.query.v1.SortDirection
+*/
+let SortDirection = /* @__PURE__ */ function(SortDirection$1) {
+	/**
+	* @generated from protobuf enum value: SORT_DIRECTION_UNSPECIFIED = 0;
+	*/
+	SortDirection$1[SortDirection$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: SORT_DIRECTION_ASC = 1;
+	*/
+	SortDirection$1[SortDirection$1["ASC"] = 1] = "ASC";
+	/**
+	* @generated from protobuf enum value: SORT_DIRECTION_DESC = 2;
+	*/
+	SortDirection$1[SortDirection$1["DESC"] = 2] = "DESC";
+	return SortDirection$1;
+}({});
+/**
+* @generated from protobuf enum tusk.drift.query.v1.SpanSortField
+*/
+let SpanSortField = /* @__PURE__ */ function(SpanSortField$1) {
+	/**
+	* @generated from protobuf enum value: SPAN_SORT_FIELD_UNSPECIFIED = 0;
+	*/
+	SpanSortField$1[SpanSortField$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: SPAN_SORT_FIELD_TIMESTAMP = 1;
+	*/
+	SpanSortField$1[SpanSortField$1["TIMESTAMP"] = 1] = "TIMESTAMP";
+	/**
+	* @generated from protobuf enum value: SPAN_SORT_FIELD_CREATED_AT = 2;
+	*/
+	SpanSortField$1[SpanSortField$1["CREATED_AT"] = 2] = "CREATED_AT";
+	/**
+	* @generated from protobuf enum value: SPAN_SORT_FIELD_UPDATED_AT = 3;
+	*/
+	SpanSortField$1[SpanSortField$1["UPDATED_AT"] = 3] = "UPDATED_AT";
+	/**
+	* @generated from protobuf enum value: SPAN_SORT_FIELD_DURATION = 4;
+	*/
+	SpanSortField$1[SpanSortField$1["DURATION"] = 4] = "DURATION";
+	/**
+	* @generated from protobuf enum value: SPAN_SORT_FIELD_NAME = 5;
+	*/
+	SpanSortField$1[SpanSortField$1["NAME"] = 5] = "NAME";
+	/**
+	* @generated from protobuf enum value: SPAN_SORT_FIELD_TRACE_ID = 6;
+	*/
+	SpanSortField$1[SpanSortField$1["TRACE_ID"] = 6] = "TRACE_ID";
+	return SpanSortField$1;
+}({});
+/**
+* @generated from protobuf enum tusk.drift.query.v1.AggregateMetric
+*/
+let AggregateMetric = /* @__PURE__ */ function(AggregateMetric$1) {
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_UNSPECIFIED = 0;
+	*/
+	AggregateMetric$1[AggregateMetric$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_COUNT = 1;
+	*/
+	AggregateMetric$1[AggregateMetric$1["COUNT"] = 1] = "COUNT";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_ERROR_COUNT = 2;
+	*/
+	AggregateMetric$1[AggregateMetric$1["ERROR_COUNT"] = 2] = "ERROR_COUNT";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_ERROR_RATE = 3;
+	*/
+	AggregateMetric$1[AggregateMetric$1["ERROR_RATE"] = 3] = "ERROR_RATE";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_AVG_DURATION = 4;
+	*/
+	AggregateMetric$1[AggregateMetric$1["AVG_DURATION"] = 4] = "AVG_DURATION";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_MIN_DURATION = 5;
+	*/
+	AggregateMetric$1[AggregateMetric$1["MIN_DURATION"] = 5] = "MIN_DURATION";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_MAX_DURATION = 6;
+	*/
+	AggregateMetric$1[AggregateMetric$1["MAX_DURATION"] = 6] = "MAX_DURATION";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_P50_DURATION = 7;
+	*/
+	AggregateMetric$1[AggregateMetric$1["P50_DURATION"] = 7] = "P50_DURATION";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_P95_DURATION = 8;
+	*/
+	AggregateMetric$1[AggregateMetric$1["P95_DURATION"] = 8] = "P95_DURATION";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_METRIC_P99_DURATION = 9;
+	*/
+	AggregateMetric$1[AggregateMetric$1["P99_DURATION"] = 9] = "P99_DURATION";
+	return AggregateMetric$1;
+}({});
+/**
+* @generated from protobuf enum tusk.drift.query.v1.AggregateGroupField
+*/
+let AggregateGroupField = /* @__PURE__ */ function(AggregateGroupField$1) {
+	/**
+	* @generated from protobuf enum value: AGGREGATE_GROUP_FIELD_UNSPECIFIED = 0;
+	*/
+	AggregateGroupField$1[AggregateGroupField$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_GROUP_FIELD_NAME = 1;
+	*/
+	AggregateGroupField$1[AggregateGroupField$1["NAME"] = 1] = "NAME";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_GROUP_FIELD_KIND = 2;
+	*/
+	AggregateGroupField$1[AggregateGroupField$1["KIND"] = 2] = "KIND";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_GROUP_FIELD_PACKAGE_NAME = 3;
+	*/
+	AggregateGroupField$1[AggregateGroupField$1["PACKAGE_NAME"] = 3] = "PACKAGE_NAME";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_GROUP_FIELD_INSTRUMENTATION_NAME = 4;
+	*/
+	AggregateGroupField$1[AggregateGroupField$1["INSTRUMENTATION_NAME"] = 4] = "INSTRUMENTATION_NAME";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_GROUP_FIELD_ENVIRONMENT = 5;
+	*/
+	AggregateGroupField$1[AggregateGroupField$1["ENVIRONMENT"] = 5] = "ENVIRONMENT";
+	/**
+	* @generated from protobuf enum value: AGGREGATE_GROUP_FIELD_STATUS_CODE = 6;
+	*/
+	AggregateGroupField$1[AggregateGroupField$1["STATUS_CODE"] = 6] = "STATUS_CODE";
+	return AggregateGroupField$1;
+}({});
+/**
+* @generated from protobuf enum tusk.drift.query.v1.TimeBucket
+*/
+let TimeBucket = /* @__PURE__ */ function(TimeBucket$1) {
+	/**
+	* @generated from protobuf enum value: TIME_BUCKET_UNSPECIFIED = 0;
+	*/
+	TimeBucket$1[TimeBucket$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: TIME_BUCKET_HOUR = 1;
+	*/
+	TimeBucket$1[TimeBucket$1["HOUR"] = 1] = "HOUR";
+	/**
+	* @generated from protobuf enum value: TIME_BUCKET_DAY = 2;
+	*/
+	TimeBucket$1[TimeBucket$1["DAY"] = 2] = "DAY";
+	/**
+	* @generated from protobuf enum value: TIME_BUCKET_WEEK = 3;
+	*/
+	TimeBucket$1[TimeBucket$1["WEEK"] = 3] = "WEEK";
+	return TimeBucket$1;
+}({});
+var TimestampRange$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.TimestampRange", [{
+			no: 1,
+			name: "start",
+			kind: "message",
+			T: () => Timestamp
+		}, {
+			no: 2,
+			name: "end",
+			kind: "message",
+			T: () => Timestamp
+		}]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		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.start = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.start);
+					break;
+				case 2:
+					message.end = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.end);
+					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.start) Timestamp.internalBinaryWrite(message.start, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+		if (message.end) Timestamp.internalBinaryWrite(message.end, writer.tag(2, 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.query.v1.TimestampRange
+*/
+const TimestampRange = new TimestampRange$Type();
+var FieldAccess$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.FieldAccess", [
+			{
+				no: 1,
+				name: "cast_as",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.query.v1.CastType",
+					CastType,
+					"CAST_TYPE_"
+				]
+			},
+			{
+				no: 2,
+				name: "decode",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.query.v1.DecodeStrategy",
+					DecodeStrategy,
+					"DECODE_STRATEGY_"
+				]
+			},
+			{
+				no: 3,
+				name: "then_path",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.castAs = 0;
+		message.decode = 0;
+		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.castAs = reader.int32();
+					break;
+				case 2:
+					message.decode = reader.int32();
+					break;
+				case 3:
+					message.thenPath = 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.castAs !== 0) writer.tag(1, WireType.Varint).int32(message.castAs);
+		if (message.decode !== 0) writer.tag(2, WireType.Varint).int32(message.decode);
+		if (message.thenPath !== void 0) writer.tag(3, WireType.LengthDelimited).string(message.thenPath);
+		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.query.v1.FieldAccess
+*/
+const FieldAccess = new FieldAccess$Type();
+var FieldPredicate$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.FieldPredicate", [
+			{
+				no: 1,
+				name: "eq",
+				kind: "message",
+				T: () => Value
+			},
+			{
+				no: 2,
+				name: "neq",
+				kind: "message",
+				T: () => Value
+			},
+			{
+				no: 3,
+				name: "in_values",
+				kind: "message",
+				repeat: 2,
+				T: () => Value
+			},
+			{
+				no: 4,
+				name: "not_in_values",
+				kind: "message",
+				repeat: 2,
+				T: () => Value
+			},
+			{
+				no: 5,
+				name: "gt",
+				kind: "message",
+				T: () => Value
+			},
+			{
+				no: 6,
+				name: "gte",
+				kind: "message",
+				T: () => Value
+			},
+			{
+				no: 7,
+				name: "lt",
+				kind: "message",
+				T: () => Value
+			},
+			{
+				no: 8,
+				name: "lte",
+				kind: "message",
+				T: () => Value
+			},
+			{
+				no: 9,
+				name: "contains",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 10,
+				name: "starts_with",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 11,
+				name: "ends_with",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 12,
+				name: "is_null",
+				kind: "scalar",
+				opt: true,
+				T: 8
+			},
+			{
+				no: 13,
+				name: "between_timestamps",
+				kind: "message",
+				T: () => TimestampRange
+			},
+			{
+				no: 14,
+				name: "access",
+				kind: "message",
+				T: () => FieldAccess
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.inValues = [];
+		message.notInValues = [];
+		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.eq = Value.internalBinaryRead(reader, reader.uint32(), options, message.eq);
+					break;
+				case 2:
+					message.neq = Value.internalBinaryRead(reader, reader.uint32(), options, message.neq);
+					break;
+				case 3:
+					message.inValues.push(Value.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 4:
+					message.notInValues.push(Value.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 5:
+					message.gt = Value.internalBinaryRead(reader, reader.uint32(), options, message.gt);
+					break;
+				case 6:
+					message.gte = Value.internalBinaryRead(reader, reader.uint32(), options, message.gte);
+					break;
+				case 7:
+					message.lt = Value.internalBinaryRead(reader, reader.uint32(), options, message.lt);
+					break;
+				case 8:
+					message.lte = Value.internalBinaryRead(reader, reader.uint32(), options, message.lte);
+					break;
+				case 9:
+					message.contains = reader.string();
+					break;
+				case 10:
+					message.startsWith = reader.string();
+					break;
+				case 11:
+					message.endsWith = reader.string();
+					break;
+				case 12:
+					message.isNull = reader.bool();
+					break;
+				case 13:
+					message.betweenTimestamps = TimestampRange.internalBinaryRead(reader, reader.uint32(), options, message.betweenTimestamps);
+					break;
+				case 14:
+					message.access = FieldAccess.internalBinaryRead(reader, reader.uint32(), options, message.access);
+					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.eq) Value.internalBinaryWrite(message.eq, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+		if (message.neq) Value.internalBinaryWrite(message.neq, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+		for (let i = 0; i < message.inValues.length; i++) Value.internalBinaryWrite(message.inValues[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		for (let i = 0; i < message.notInValues.length; i++) Value.internalBinaryWrite(message.notInValues[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.gt) Value.internalBinaryWrite(message.gt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+		if (message.gte) Value.internalBinaryWrite(message.gte, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+		if (message.lt) Value.internalBinaryWrite(message.lt, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+		if (message.lte) Value.internalBinaryWrite(message.lte, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+		if (message.contains !== void 0) writer.tag(9, WireType.LengthDelimited).string(message.contains);
+		if (message.startsWith !== void 0) writer.tag(10, WireType.LengthDelimited).string(message.startsWith);
+		if (message.endsWith !== void 0) writer.tag(11, WireType.LengthDelimited).string(message.endsWith);
+		if (message.isNull !== void 0) writer.tag(12, WireType.Varint).bool(message.isNull);
+		if (message.betweenTimestamps) TimestampRange.internalBinaryWrite(message.betweenTimestamps, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+		if (message.access) FieldAccess.internalBinaryWrite(message.access, writer.tag(14, 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.query.v1.FieldPredicate
+*/
+const FieldPredicate = new FieldPredicate$Type();
+var WhereClause$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.WhereClause", [
+			{
+				no: 1,
+				name: "fields",
+				kind: "map",
+				K: 9,
+				V: {
+					kind: "message",
+					T: () => FieldPredicate
+				}
+			},
+			{
+				no: 2,
+				name: "and",
+				kind: "message",
+				repeat: 2,
+				T: () => WhereClause
+			},
+			{
+				no: 3,
+				name: "or",
+				kind: "message",
+				repeat: 2,
+				T: () => WhereClause
+			},
+			{
+				no: 4,
+				name: "not",
+				kind: "message",
+				T: () => WhereClause
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.fields = {};
+		message.and = [];
+		message.or = [];
+		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:
+					this.binaryReadMap1(message.fields, reader, options);
+					break;
+				case 2:
+					message.and.push(WhereClause.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 3:
+					message.or.push(WhereClause.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 4:
+					message.not = WhereClause.internalBinaryRead(reader, reader.uint32(), options, message.not);
+					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;
+	}
+	binaryReadMap1(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 = FieldPredicate.internalBinaryRead(reader, reader.uint32(), options);
+					break;
+				default: throw new globalThis.Error("unknown map entry field for tusk.drift.query.v1.WhereClause.fields");
+			}
+		}
+		map[key ?? ""] = val ?? FieldPredicate.create();
+	}
+	internalBinaryWrite(message, writer, options) {
+		for (let k of globalThis.Object.keys(message.fields)) {
+			writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+			writer.tag(2, WireType.LengthDelimited).fork();
+			FieldPredicate.internalBinaryWrite(message.fields[k], writer, options);
+			writer.join().join();
+		}
+		for (let i = 0; i < message.and.length; i++) WhereClause.internalBinaryWrite(message.and[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+		for (let i = 0; i < message.or.length; i++) WhereClause.internalBinaryWrite(message.or[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		if (message.not) WhereClause.internalBinaryWrite(message.not, writer.tag(4, 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.query.v1.WhereClause
+*/
+const WhereClause = new WhereClause$Type();
+var SpanOrderBy$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.SpanOrderBy", [{
+			no: 1,
+			name: "field",
+			kind: "enum",
+			T: () => [
+				"tusk.drift.query.v1.SpanSortField",
+				SpanSortField,
+				"SPAN_SORT_FIELD_"
+			]
+		}, {
+			no: 2,
+			name: "direction",
+			kind: "enum",
+			T: () => [
+				"tusk.drift.query.v1.SortDirection",
+				SortDirection,
+				"SORT_DIRECTION_"
+			]
+		}]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.field = 0;
+		message.direction = 0;
+		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.field = reader.int32();
+					break;
+				case 2:
+					message.direction = reader.int32();
+					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.field !== 0) writer.tag(1, WireType.Varint).int32(message.field);
+		if (message.direction !== 0) writer.tag(2, WireType.Varint).int32(message.direction);
+		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.query.v1.SpanOrderBy
+*/
+const SpanOrderBy = new SpanOrderBy$Type();
+var MetricOrderBy$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.MetricOrderBy", [{
+			no: 1,
+			name: "metric",
+			kind: "enum",
+			T: () => [
+				"tusk.drift.query.v1.AggregateMetric",
+				AggregateMetric,
+				"AGGREGATE_METRIC_"
+			]
+		}, {
+			no: 2,
+			name: "direction",
+			kind: "enum",
+			T: () => [
+				"tusk.drift.query.v1.SortDirection",
+				SortDirection,
+				"SORT_DIRECTION_"
+			]
+		}]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.metric = 0;
+		message.direction = 0;
+		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.metric = reader.int32();
+					break;
+				case 2:
+					message.direction = reader.int32();
+					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.metric !== 0) writer.tag(1, WireType.Varint).int32(message.metric);
+		if (message.direction !== 0) writer.tag(2, WireType.Varint).int32(message.direction);
+		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.query.v1.MetricOrderBy
+*/
+const MetricOrderBy = new MetricOrderBy$Type();
+var SchemaComparisonPeriod$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.SchemaComparisonPeriod", [{
+			no: 1,
+			name: "start_date",
+			kind: "message",
+			T: () => Timestamp
+		}, {
+			no: 2,
+			name: "end_date",
+			kind: "message",
+			T: () => Timestamp
+		}]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		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.startDate = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.startDate);
+					break;
+				case 2:
+					message.endDate = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.endDate);
+					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.startDate) Timestamp.internalBinaryWrite(message.startDate, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+		if (message.endDate) Timestamp.internalBinaryWrite(message.endDate, writer.tag(2, 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.query.v1.SchemaComparisonPeriod
+*/
+const SchemaComparisonPeriod = new SchemaComparisonPeriod$Type();
+var QuerySpansRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.QuerySpansRequest", [
+			{
+				no: 1,
+				name: "observable_service_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "client_id",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 3,
+				name: "where",
+				kind: "message",
+				T: () => WhereClause
+			},
+			{
+				no: 4,
+				name: "order_by",
+				kind: "message",
+				repeat: 2,
+				T: () => SpanOrderBy
+			},
+			{
+				no: 5,
+				name: "limit",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			},
+			{
+				no: 6,
+				name: "offset",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			},
+			{
+				no: 7,
+				name: "include_payloads",
+				kind: "scalar",
+				opt: true,
+				T: 8
+			},
+			{
+				no: 8,
+				name: "max_payload_length",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.observableServiceId = "";
+		message.orderBy = [];
+		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.observableServiceId = reader.string();
+					break;
+				case 2:
+					message.clientId = reader.string();
+					break;
+				case 3:
+					message.where = WhereClause.internalBinaryRead(reader, reader.uint32(), options, message.where);
+					break;
+				case 4:
+					message.orderBy.push(SpanOrderBy.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 5:
+					message.limit = reader.int32();
+					break;
+				case 6:
+					message.offset = reader.int32();
+					break;
+				case 7:
+					message.includePayloads = reader.bool();
+					break;
+				case 8:
+					message.maxPayloadLength = reader.int32();
+					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.observableServiceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.observableServiceId);
+		if (message.clientId !== void 0) writer.tag(2, WireType.LengthDelimited).string(message.clientId);
+		if (message.where) WhereClause.internalBinaryWrite(message.where, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		for (let i = 0; i < message.orderBy.length; i++) SpanOrderBy.internalBinaryWrite(message.orderBy[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.limit !== void 0) writer.tag(5, WireType.Varint).int32(message.limit);
+		if (message.offset !== void 0) writer.tag(6, WireType.Varint).int32(message.offset);
+		if (message.includePayloads !== void 0) writer.tag(7, WireType.Varint).bool(message.includePayloads);
+		if (message.maxPayloadLength !== void 0) writer.tag(8, WireType.Varint).int32(message.maxPayloadLength);
+		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.query.v1.QuerySpansRequest
+*/
+const QuerySpansRequest = new QuerySpansRequest$Type();
+var GetSchemaRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.GetSchemaRequest", [
+			{
+				no: 1,
+				name: "observable_service_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "package_name",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 3,
+				name: "instrumentation_name",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 4,
+				name: "name",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 5,
+				name: "show_example",
+				kind: "scalar",
+				opt: true,
+				T: 8
+			},
+			{
+				no: 6,
+				name: "max_payload_length",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.observableServiceId = "";
+		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.observableServiceId = reader.string();
+					break;
+				case 2:
+					message.packageName = reader.string();
+					break;
+				case 3:
+					message.instrumentationName = reader.string();
+					break;
+				case 4:
+					message.name = reader.string();
+					break;
+				case 5:
+					message.showExample = reader.bool();
+					break;
+				case 6:
+					message.maxPayloadLength = reader.int32();
+					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.observableServiceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.observableServiceId);
+		if (message.packageName !== void 0) writer.tag(2, WireType.LengthDelimited).string(message.packageName);
+		if (message.instrumentationName !== void 0) writer.tag(3, WireType.LengthDelimited).string(message.instrumentationName);
+		if (message.name !== void 0) writer.tag(4, WireType.LengthDelimited).string(message.name);
+		if (message.showExample !== void 0) writer.tag(5, WireType.Varint).bool(message.showExample);
+		if (message.maxPayloadLength !== void 0) writer.tag(6, WireType.Varint).int32(message.maxPayloadLength);
+		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.query.v1.GetSchemaRequest
+*/
+const GetSchemaRequest = new GetSchemaRequest$Type();
+var ListDistinctValuesRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.ListDistinctValuesRequest", [
+			{
+				no: 1,
+				name: "observable_service_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "client_id",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 3,
+				name: "field",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "where",
+				kind: "message",
+				T: () => WhereClause
+			},
+			{
+				no: 5,
+				name: "limit",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.observableServiceId = "";
+		message.field = "";
+		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.observableServiceId = reader.string();
+					break;
+				case 2:
+					message.clientId = reader.string();
+					break;
+				case 3:
+					message.field = reader.string();
+					break;
+				case 4:
+					message.where = WhereClause.internalBinaryRead(reader, reader.uint32(), options, message.where);
+					break;
+				case 5:
+					message.limit = reader.int32();
+					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.observableServiceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.observableServiceId);
+		if (message.clientId !== void 0) writer.tag(2, WireType.LengthDelimited).string(message.clientId);
+		if (message.field !== "") writer.tag(3, WireType.LengthDelimited).string(message.field);
+		if (message.where) WhereClause.internalBinaryWrite(message.where, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.limit !== void 0) writer.tag(5, WireType.Varint).int32(message.limit);
+		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.query.v1.ListDistinctValuesRequest
+*/
+const ListDistinctValuesRequest = new ListDistinctValuesRequest$Type();
+var AggregateSpansRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.AggregateSpansRequest", [
+			{
+				no: 1,
+				name: "observable_service_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "client_id",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 3,
+				name: "where",
+				kind: "message",
+				T: () => WhereClause
+			},
+			{
+				no: 4,
+				name: "group_by",
+				kind: "enum",
+				repeat: 1,
+				T: () => [
+					"tusk.drift.query.v1.AggregateGroupField",
+					AggregateGroupField,
+					"AGGREGATE_GROUP_FIELD_"
+				]
+			},
+			{
+				no: 5,
+				name: "metrics",
+				kind: "enum",
+				repeat: 1,
+				T: () => [
+					"tusk.drift.query.v1.AggregateMetric",
+					AggregateMetric,
+					"AGGREGATE_METRIC_"
+				]
+			},
+			{
+				no: 6,
+				name: "time_bucket",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.query.v1.TimeBucket",
+					TimeBucket,
+					"TIME_BUCKET_"
+				]
+			},
+			{
+				no: 7,
+				name: "order_by",
+				kind: "message",
+				T: () => MetricOrderBy
+			},
+			{
+				no: 8,
+				name: "limit",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.observableServiceId = "";
+		message.groupBy = [];
+		message.metrics = [];
+		message.timeBucket = 0;
+		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.observableServiceId = reader.string();
+					break;
+				case 2:
+					message.clientId = reader.string();
+					break;
+				case 3:
+					message.where = WhereClause.internalBinaryRead(reader, reader.uint32(), options, message.where);
+					break;
+				case 4:
+					if (wireType === WireType.LengthDelimited) for (let e = reader.int32() + reader.pos; reader.pos < e;) message.groupBy.push(reader.int32());
+					else message.groupBy.push(reader.int32());
+					break;
+				case 5:
+					if (wireType === WireType.LengthDelimited) for (let e = reader.int32() + reader.pos; reader.pos < e;) message.metrics.push(reader.int32());
+					else message.metrics.push(reader.int32());
+					break;
+				case 6:
+					message.timeBucket = reader.int32();
+					break;
+				case 7:
+					message.orderBy = MetricOrderBy.internalBinaryRead(reader, reader.uint32(), options, message.orderBy);
+					break;
+				case 8:
+					message.limit = reader.int32();
+					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.observableServiceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.observableServiceId);
+		if (message.clientId !== void 0) writer.tag(2, WireType.LengthDelimited).string(message.clientId);
+		if (message.where) WhereClause.internalBinaryWrite(message.where, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		if (message.groupBy.length) {
+			writer.tag(4, WireType.LengthDelimited).fork();
+			for (let i = 0; i < message.groupBy.length; i++) writer.int32(message.groupBy[i]);
+			writer.join();
+		}
+		if (message.metrics.length) {
+			writer.tag(5, WireType.LengthDelimited).fork();
+			for (let i = 0; i < message.metrics.length; i++) writer.int32(message.metrics[i]);
+			writer.join();
+		}
+		if (message.timeBucket !== 0) writer.tag(6, WireType.Varint).int32(message.timeBucket);
+		if (message.orderBy) MetricOrderBy.internalBinaryWrite(message.orderBy, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+		if (message.limit !== void 0) writer.tag(8, WireType.Varint).int32(message.limit);
+		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.query.v1.AggregateSpansRequest
+*/
+const AggregateSpansRequest = new AggregateSpansRequest$Type();
+var GetTraceSpansRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.GetTraceSpansRequest", [
+			{
+				no: 1,
+				name: "observable_service_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "client_id",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 3,
+				name: "trace_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "include_payloads",
+				kind: "scalar",
+				opt: true,
+				T: 8
+			},
+			{
+				no: 5,
+				name: "max_payload_length",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.observableServiceId = "";
+		message.traceId = "";
+		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.observableServiceId = reader.string();
+					break;
+				case 2:
+					message.clientId = reader.string();
+					break;
+				case 3:
+					message.traceId = reader.string();
+					break;
+				case 4:
+					message.includePayloads = reader.bool();
+					break;
+				case 5:
+					message.maxPayloadLength = reader.int32();
+					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.observableServiceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.observableServiceId);
+		if (message.clientId !== void 0) writer.tag(2, WireType.LengthDelimited).string(message.clientId);
+		if (message.traceId !== "") writer.tag(3, WireType.LengthDelimited).string(message.traceId);
+		if (message.includePayloads !== void 0) writer.tag(4, WireType.Varint).bool(message.includePayloads);
+		if (message.maxPayloadLength !== void 0) writer.tag(5, WireType.Varint).int32(message.maxPayloadLength);
+		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.query.v1.GetTraceSpansRequest
+*/
+const GetTraceSpansRequest = new GetTraceSpansRequest$Type();
+var GetSpansByIdsRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.GetSpansByIdsRequest", [
+			{
+				no: 1,
+				name: "observable_service_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "ids",
+				kind: "scalar",
+				repeat: 2,
+				T: 9
+			},
+			{
+				no: 3,
+				name: "fields",
+				kind: "enum",
+				repeat: 1,
+				T: () => [
+					"tusk.drift.query.v1.SelectableSpanField",
+					SelectableSpanField,
+					"SELECTABLE_SPAN_FIELD_"
+				]
+			},
+			{
+				no: 4,
+				name: "include_payloads",
+				kind: "scalar",
+				opt: true,
+				T: 8
+			},
+			{
+				no: 5,
+				name: "max_payload_length",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.observableServiceId = "";
+		message.ids = [];
+		message.fields = [];
+		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.observableServiceId = reader.string();
+					break;
+				case 2:
+					message.ids.push(reader.string());
+					break;
+				case 3:
+					if (wireType === WireType.LengthDelimited) for (let e = reader.int32() + reader.pos; reader.pos < e;) message.fields.push(reader.int32());
+					else message.fields.push(reader.int32());
+					break;
+				case 4:
+					message.includePayloads = reader.bool();
+					break;
+				case 5:
+					message.maxPayloadLength = reader.int32();
+					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.observableServiceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.observableServiceId);
+		for (let i = 0; i < message.ids.length; i++) writer.tag(2, WireType.LengthDelimited).string(message.ids[i]);
+		if (message.fields.length) {
+			writer.tag(3, WireType.LengthDelimited).fork();
+			for (let i = 0; i < message.fields.length; i++) writer.int32(message.fields[i]);
+			writer.join();
+		}
+		if (message.includePayloads !== void 0) writer.tag(4, WireType.Varint).bool(message.includePayloads);
+		if (message.maxPayloadLength !== void 0) writer.tag(5, WireType.Varint).int32(message.maxPayloadLength);
+		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.query.v1.GetSpansByIdsRequest
+*/
+const GetSpansByIdsRequest = new GetSpansByIdsRequest$Type();
+var CompareSchemaRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.query.v1.CompareSchemaRequest", [
+			{
+				no: 1,
+				name: "observable_service_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "client_id",
+				kind: "scalar",
+				opt: true,
+				T: 9
+			},
+			{
+				no: 3,
+				name: "name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "period_a",
+				kind: "message",
+				T: () => SchemaComparisonPeriod
+			},
+			{
+				no: 5,
+				name: "period_b",
+				kind: "message",
+				T: () => SchemaComparisonPeriod
+			},
+			{
+				no: 6,
+				name: "include_payloads",
+				kind: "scalar",
+				opt: true,
+				T: 8
+			},
+			{
+				no: 7,
+				name: "max_payload_length",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.observableServiceId = "";
+		message.name = "";
+		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.observableServiceId = reader.string();
+					break;
+				case 2:
+					message.clientId = reader.string();
+					break;
+				case 3:
+					message.name = reader.string();
+					break;
+				case 4:
+					message.periodA = SchemaComparisonPeriod.internalBinaryRead(reader, reader.uint32(), options, message.periodA);
+					break;
+				case 5:
+					message.periodB = SchemaComparisonPeriod.internalBinaryRead(reader, reader.uint32(), options, message.periodB);
+					break;
+				case 6:
+					message.includePayloads = reader.bool();
+					break;
+				case 7:
+					message.maxPayloadLength = reader.int32();
+					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.observableServiceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.observableServiceId);
+		if (message.clientId !== void 0) writer.tag(2, WireType.LengthDelimited).string(message.clientId);
+		if (message.name !== "") writer.tag(3, WireType.LengthDelimited).string(message.name);
+		if (message.periodA) SchemaComparisonPeriod.internalBinaryWrite(message.periodA, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.periodB) SchemaComparisonPeriod.internalBinaryWrite(message.periodB, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+		if (message.includePayloads !== void 0) writer.tag(6, WireType.Varint).bool(message.includePayloads);
+		if (message.maxPayloadLength !== void 0) writer.tag(7, WireType.Varint).int32(message.maxPayloadLength);
+		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.query.v1.CompareSchemaRequest
+*/
+const CompareSchemaRequest = new CompareSchemaRequest$Type();
+
+//#endregion
+//#region src/query/span_query_helpers.ts
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+function snakeToCamelCase(value) {
+	return value.toLowerCase().replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function createEnumCodec(enumObject, mapKey) {
+	const pairs = Object.entries(enumObject).filter((entry) => entry[0] !== "UNSPECIFIED" && typeof entry[1] === "number").map(([key, value]) => [mapKey(key), value]);
+	const reversePairs = pairs.map(([name, value]) => [value, name]);
+	const byName = Object.freeze(Object.fromEntries(pairs));
+	const byValue = Object.freeze(Object.fromEntries(reversePairs));
+	return {
+		names: Object.freeze(pairs.map(([name]) => name)),
+		values: Object.freeze(pairs.map(([, value]) => value)),
+		byName,
+		byValue,
+		normalize(value) {
+			if (typeof value === "string") return hasOwn(byName, value) ? value : null;
+			return hasOwn(byValue, value) ? byValue[value] : null;
+		},
+		isName(value) {
+			return typeof value === "string" && hasOwn(byName, value);
+		},
+		isValue(value) {
+			return typeof value === "number" && Number.isInteger(value) && hasOwn(byValue, value);
+		}
+	};
+}
+function createCamelCaseEnumCodec(enumObject) {
+	return createEnumCodec(enumObject, (key) => snakeToCamelCase(key));
+}
+function createIdentityEnumCodec(enumObject) {
+	return createEnumCodec(enumObject, (key) => key);
+}
+const selectableSpanFieldCodec = createCamelCaseEnumCodec(SelectableSpanField);
+const castTypeCodec = createCamelCaseEnumCodec(CastType);
+const decodeStrategyCodec = createCamelCaseEnumCodec(DecodeStrategy);
+const spanSortFieldCodec = createCamelCaseEnumCodec(SpanSortField);
+const aggregateMetricCodec = createCamelCaseEnumCodec(AggregateMetric);
+const aggregateGroupFieldCodec = createCamelCaseEnumCodec(AggregateGroupField);
+const timeBucketCodec = createCamelCaseEnumCodec(TimeBucket);
+const sortDirectionCodec = createIdentityEnumCodec(SortDirection);
+
+//#endregion
+export { aggregateGroupFieldCodec, aggregateMetricCodec, castTypeCodec, decodeStrategyCodec, selectableSpanFieldCodec, sortDirectionCodec, spanSortFieldCodec, timeBucketCodec };
+//# sourceMappingURL=span_query_helpers.js.map