@use-tusk/drift-schemas 0.1.10

package/dist/communication-Np8Uorqu.js

@@ -0,0 +1,725 @@
+import { Struct } from "./struct-LJz5_MGH.js";
+import { Timestamp } from "./timestamp-CN7C70ih.js";
+import { Span } from "./span-DwoKrEhp.js";
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import { MessageType, UnknownFieldHandler, WireType, reflectionMergePartial } from "@protobuf-ts/runtime";
+
+//#region generated/ts/core/communication.ts
+/**
+* @generated from protobuf enum tusk.drift.core.v1.MessageType
+*/
+let MessageType$1 = /* @__PURE__ */ function(MessageType$2) {
+	/**
+	* @generated from protobuf enum value: MESSAGE_TYPE_UNSPECIFIED = 0;
+	*/
+	MessageType$2[MessageType$2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: MESSAGE_TYPE_SDK_CONNECT = 1;
+	*/
+	MessageType$2[MessageType$2["SDK_CONNECT"] = 1] = "SDK_CONNECT";
+	/**
+	* @generated from protobuf enum value: MESSAGE_TYPE_MOCK_REQUEST = 2;
+	*/
+	MessageType$2[MessageType$2["MOCK_REQUEST"] = 2] = "MOCK_REQUEST";
+	/**
+	* @generated from protobuf enum value: MESSAGE_TYPE_INBOUND_SPAN = 3;
+	*/
+	MessageType$2[MessageType$2["INBOUND_SPAN"] = 3] = "INBOUND_SPAN";
+	return MessageType$2;
+}({});
+var ConnectRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.ConnectRequest", [
+			{
+				no: 1,
+				name: "service_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "sdk_version",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "min_cli_version",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "metadata",
+				kind: "message",
+				T: () => Struct
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.serviceId = "";
+		message.sdkVersion = "";
+		message.minCliVersion = "";
+		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.serviceId = reader.string();
+					break;
+				case 2:
+					message.sdkVersion = reader.string();
+					break;
+				case 3:
+					message.minCliVersion = reader.string();
+					break;
+				case 4:
+					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.serviceId !== "") writer.tag(1, WireType.LengthDelimited).string(message.serviceId);
+		if (message.sdkVersion !== "") writer.tag(2, WireType.LengthDelimited).string(message.sdkVersion);
+		if (message.minCliVersion !== "") writer.tag(3, WireType.LengthDelimited).string(message.minCliVersion);
+		if (message.metadata) Struct.internalBinaryWrite(message.metadata, 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.core.v1.ConnectRequest
+*/
+const ConnectRequest = new ConnectRequest$Type();
+var ConnectResponse$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.ConnectResponse", [{
+			no: 1,
+			name: "success",
+			kind: "scalar",
+			T: 8
+		}, {
+			no: 2,
+			name: "error",
+			kind: "scalar",
+			T: 9
+		}]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.success = false;
+		message.error = "";
+		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.success = reader.bool();
+					break;
+				case 2:
+					message.error = 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.success !== false) writer.tag(1, WireType.Varint).bool(message.success);
+		if (message.error !== "") writer.tag(2, WireType.LengthDelimited).string(message.error);
+		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.ConnectResponse
+*/
+const ConnectResponse = new ConnectResponse$Type();
+var GetMockRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.GetMockRequest", [
+			{
+				no: 1,
+				name: "request_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "test_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "outbound_span",
+				kind: "message",
+				T: () => Span
+			},
+			{
+				no: 4,
+				name: "stack_trace",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 5,
+				name: "operation",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 6,
+				name: "tags",
+				kind: "map",
+				K: 9,
+				V: {
+					kind: "scalar",
+					T: 9
+				}
+			},
+			{
+				no: 7,
+				name: "requested_at",
+				kind: "message",
+				T: () => Timestamp
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.requestId = "";
+		message.testId = "";
+		message.stackTrace = "";
+		message.operation = "";
+		message.tags = {};
+		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.requestId = reader.string();
+					break;
+				case 2:
+					message.testId = reader.string();
+					break;
+				case 3:
+					message.outboundSpan = Span.internalBinaryRead(reader, reader.uint32(), options, message.outboundSpan);
+					break;
+				case 4:
+					message.stackTrace = reader.string();
+					break;
+				case 5:
+					message.operation = reader.string();
+					break;
+				case 6:
+					this.binaryReadMap6(message.tags, reader, options);
+					break;
+				case 7:
+					message.requestedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.requestedAt);
+					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;
+	}
+	binaryReadMap6(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.GetMockRequest.tags");
+			}
+		}
+		map[key ?? ""] = val ?? "";
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.requestId !== "") writer.tag(1, WireType.LengthDelimited).string(message.requestId);
+		if (message.testId !== "") writer.tag(2, WireType.LengthDelimited).string(message.testId);
+		if (message.outboundSpan) Span.internalBinaryWrite(message.outboundSpan, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		if (message.stackTrace !== "") writer.tag(4, WireType.LengthDelimited).string(message.stackTrace);
+		if (message.operation !== "") writer.tag(5, WireType.LengthDelimited).string(message.operation);
+		for (let k of globalThis.Object.keys(message.tags)) writer.tag(6, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.tags[k]).join();
+		if (message.requestedAt) Timestamp.internalBinaryWrite(message.requestedAt, writer.tag(7, 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.GetMockRequest
+*/
+const GetMockRequest = new GetMockRequest$Type();
+var GetMockResponse$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.GetMockResponse", [
+			{
+				no: 1,
+				name: "request_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "found",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 3,
+				name: "response_data",
+				kind: "message",
+				T: () => Struct
+			},
+			{
+				no: 4,
+				name: "metadata",
+				kind: "message",
+				T: () => Struct
+			},
+			{
+				no: 5,
+				name: "error",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 6,
+				name: "error_code",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 7,
+				name: "matched_span_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 8,
+				name: "matched_at",
+				kind: "message",
+				T: () => Timestamp
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.requestId = "";
+		message.found = false;
+		message.error = "";
+		message.errorCode = "";
+		message.matchedSpanId = "";
+		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.requestId = reader.string();
+					break;
+				case 2:
+					message.found = reader.bool();
+					break;
+				case 3:
+					message.responseData = Struct.internalBinaryRead(reader, reader.uint32(), options, message.responseData);
+					break;
+				case 4:
+					message.metadata = Struct.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+					break;
+				case 5:
+					message.error = reader.string();
+					break;
+				case 6:
+					message.errorCode = reader.string();
+					break;
+				case 7:
+					message.matchedSpanId = reader.string();
+					break;
+				case 8:
+					message.matchedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.matchedAt);
+					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.requestId !== "") writer.tag(1, WireType.LengthDelimited).string(message.requestId);
+		if (message.found !== false) writer.tag(2, WireType.Varint).bool(message.found);
+		if (message.responseData) Struct.internalBinaryWrite(message.responseData, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		if (message.metadata) Struct.internalBinaryWrite(message.metadata, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.error !== "") writer.tag(5, WireType.LengthDelimited).string(message.error);
+		if (message.errorCode !== "") writer.tag(6, WireType.LengthDelimited).string(message.errorCode);
+		if (message.matchedSpanId !== "") writer.tag(7, WireType.LengthDelimited).string(message.matchedSpanId);
+		if (message.matchedAt) Timestamp.internalBinaryWrite(message.matchedAt, writer.tag(8, 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.GetMockResponse
+*/
+const GetMockResponse = new GetMockResponse$Type();
+var SDKMessage$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.SDKMessage", [
+			{
+				no: 1,
+				name: "type",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.core.v1.MessageType",
+					MessageType$1,
+					"MESSAGE_TYPE_"
+				]
+			},
+			{
+				no: 2,
+				name: "request_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "connect_request",
+				kind: "message",
+				oneof: "payload",
+				T: () => ConnectRequest
+			},
+			{
+				no: 4,
+				name: "get_mock_request",
+				kind: "message",
+				oneof: "payload",
+				T: () => GetMockRequest
+			},
+			{
+				no: 5,
+				name: "send_inbound_span_for_replay_request",
+				kind: "message",
+				oneof: "payload",
+				T: () => SendInboundSpanForReplayRequest
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.type = 0;
+		message.requestId = "";
+		message.payload = { 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.type = reader.int32();
+					break;
+				case 2:
+					message.requestId = reader.string();
+					break;
+				case 3:
+					message.payload = {
+						oneofKind: "connectRequest",
+						connectRequest: ConnectRequest.internalBinaryRead(reader, reader.uint32(), options, message.payload.connectRequest)
+					};
+					break;
+				case 4:
+					message.payload = {
+						oneofKind: "getMockRequest",
+						getMockRequest: GetMockRequest.internalBinaryRead(reader, reader.uint32(), options, message.payload.getMockRequest)
+					};
+					break;
+				case 5:
+					message.payload = {
+						oneofKind: "sendInboundSpanForReplayRequest",
+						sendInboundSpanForReplayRequest: SendInboundSpanForReplayRequest.internalBinaryRead(reader, reader.uint32(), options, message.payload.sendInboundSpanForReplayRequest)
+					};
+					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.type !== 0) writer.tag(1, WireType.Varint).int32(message.type);
+		if (message.requestId !== "") writer.tag(2, WireType.LengthDelimited).string(message.requestId);
+		if (message.payload.oneofKind === "connectRequest") ConnectRequest.internalBinaryWrite(message.payload.connectRequest, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		if (message.payload.oneofKind === "getMockRequest") GetMockRequest.internalBinaryWrite(message.payload.getMockRequest, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.payload.oneofKind === "sendInboundSpanForReplayRequest") SendInboundSpanForReplayRequest.internalBinaryWrite(message.payload.sendInboundSpanForReplayRequest, writer.tag(5, 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.SDKMessage
+*/
+const SDKMessage = new SDKMessage$Type();
+var CLIMessage$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.CLIMessage", [
+			{
+				no: 1,
+				name: "type",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.core.v1.MessageType",
+					MessageType$1,
+					"MESSAGE_TYPE_"
+				]
+			},
+			{
+				no: 2,
+				name: "request_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "connect_response",
+				kind: "message",
+				oneof: "payload",
+				T: () => ConnectResponse
+			},
+			{
+				no: 4,
+				name: "get_mock_response",
+				kind: "message",
+				oneof: "payload",
+				T: () => GetMockResponse
+			},
+			{
+				no: 5,
+				name: "send_inbound_span_for_replay_response",
+				kind: "message",
+				oneof: "payload",
+				T: () => SendInboundSpanForReplayResponse
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.type = 0;
+		message.requestId = "";
+		message.payload = { 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.type = reader.int32();
+					break;
+				case 2:
+					message.requestId = reader.string();
+					break;
+				case 3:
+					message.payload = {
+						oneofKind: "connectResponse",
+						connectResponse: ConnectResponse.internalBinaryRead(reader, reader.uint32(), options, message.payload.connectResponse)
+					};
+					break;
+				case 4:
+					message.payload = {
+						oneofKind: "getMockResponse",
+						getMockResponse: GetMockResponse.internalBinaryRead(reader, reader.uint32(), options, message.payload.getMockResponse)
+					};
+					break;
+				case 5:
+					message.payload = {
+						oneofKind: "sendInboundSpanForReplayResponse",
+						sendInboundSpanForReplayResponse: SendInboundSpanForReplayResponse.internalBinaryRead(reader, reader.uint32(), options, message.payload.sendInboundSpanForReplayResponse)
+					};
+					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.type !== 0) writer.tag(1, WireType.Varint).int32(message.type);
+		if (message.requestId !== "") writer.tag(2, WireType.LengthDelimited).string(message.requestId);
+		if (message.payload.oneofKind === "connectResponse") ConnectResponse.internalBinaryWrite(message.payload.connectResponse, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		if (message.payload.oneofKind === "getMockResponse") GetMockResponse.internalBinaryWrite(message.payload.getMockResponse, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.payload.oneofKind === "sendInboundSpanForReplayResponse") SendInboundSpanForReplayResponse.internalBinaryWrite(message.payload.sendInboundSpanForReplayResponse, writer.tag(5, 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.CLIMessage
+*/
+const CLIMessage = new CLIMessage$Type();
+var SendInboundSpanForReplayRequest$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.SendInboundSpanForReplayRequest", [{
+			no: 1,
+			name: "span",
+			kind: "message",
+			T: () => Span
+		}]);
+	}
+	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.span = Span.internalBinaryRead(reader, reader.uint32(), options, message.span);
+					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.span) Span.internalBinaryWrite(message.span, 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 tusk.drift.core.v1.SendInboundSpanForReplayRequest
+*/
+const SendInboundSpanForReplayRequest = new SendInboundSpanForReplayRequest$Type();
+var SendInboundSpanForReplayResponse$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.core.v1.SendInboundSpanForReplayResponse", [{
+			no: 1,
+			name: "success",
+			kind: "scalar",
+			T: 8
+		}]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.success = 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.success = reader.bool();
+					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.success !== false) writer.tag(1, WireType.Varint).bool(message.success);
+		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.SendInboundSpanForReplayResponse
+*/
+const SendInboundSpanForReplayResponse = new SendInboundSpanForReplayResponse$Type();
+/**
+* @generated ServiceType for protobuf service tusk.drift.core.v1.MockService
+*/
+const MockService = new ServiceType("tusk.drift.core.v1.MockService", [
+	{
+		name: "Connect",
+		options: {},
+		I: ConnectRequest,
+		O: ConnectResponse
+	},
+	{
+		name: "GetMock",
+		options: {},
+		I: GetMockRequest,
+		O: GetMockResponse
+	},
+	{
+		name: "SendInboundSpanForReplay",
+		options: {},
+		I: SendInboundSpanForReplayRequest,
+		O: SendInboundSpanForReplayResponse
+	}
+]);
+
+//#endregion
+export { CLIMessage, ConnectRequest, ConnectResponse, GetMockRequest, GetMockResponse, MessageType$1 as MessageType, MockService, SDKMessage, SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse };
+//# sourceMappingURL=communication-Np8Uorqu.js.map