@teslemetry/tesla-protocol 0.1.1

package/dist/command/universal_message.mjs

@@ -0,0 +1,571 @@
+import { SignatureData } from "./signatures.mjs";
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+//#region src/command/universal_message.ts
+const protobufPackage = "UniversalMessage";
+/**
+* UPSTREAM-SOURCE: teslamotors/vehicle-command
+* UPSTREAM-PATH:   pkg/protocol/protobuf/universal_message.proto
+* UPSTREAM-COMMIT: see upstream.json
+* This file = upstream base + Teslemetry extensions marked TESLEMETRY-EXT.
+*/
+let Domain = /* @__PURE__ */ function(Domain) {
+	Domain[Domain["DOMAIN_BROADCAST"] = 0] = "DOMAIN_BROADCAST";
+	Domain[Domain["DOMAIN_VEHICLE_SECURITY"] = 2] = "DOMAIN_VEHICLE_SECURITY";
+	Domain[Domain["DOMAIN_INFOTAINMENT"] = 3] = "DOMAIN_INFOTAINMENT";
+	/** DOMAIN_AUTHD - TESLEMETRY-EXT (app-4.58.6) */
+	Domain[Domain["DOMAIN_AUTHD"] = 5] = "DOMAIN_AUTHD";
+	/** DOMAIN_ENERGY_DEVICE - TESLEMETRY-EXT (app-4.58.6) */
+	Domain[Domain["DOMAIN_ENERGY_DEVICE"] = 7] = "DOMAIN_ENERGY_DEVICE";
+	/** DOMAIN_ENERGY_DEVICE_AUTH - TESLEMETRY-EXT (app-4.58.6) */
+	Domain[Domain["DOMAIN_ENERGY_DEVICE_AUTH"] = 8] = "DOMAIN_ENERGY_DEVICE_AUTH";
+	Domain[Domain["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return Domain;
+}({});
+function domainFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "DOMAIN_BROADCAST": return 0;
+		case 2:
+		case "DOMAIN_VEHICLE_SECURITY": return 2;
+		case 3:
+		case "DOMAIN_INFOTAINMENT": return 3;
+		case 5:
+		case "DOMAIN_AUTHD": return 5;
+		case 7:
+		case "DOMAIN_ENERGY_DEVICE": return 7;
+		case 8:
+		case "DOMAIN_ENERGY_DEVICE_AUTH": return 8;
+		default: return -1;
+	}
+}
+function domainToJSON(object) {
+	switch (object) {
+		case 0: return "DOMAIN_BROADCAST";
+		case 2: return "DOMAIN_VEHICLE_SECURITY";
+		case 3: return "DOMAIN_INFOTAINMENT";
+		case 5: return "DOMAIN_AUTHD";
+		case 7: return "DOMAIN_ENERGY_DEVICE";
+		case 8: return "DOMAIN_ENERGY_DEVICE_AUTH";
+		default: return "UNRECOGNIZED";
+	}
+}
+let OperationStatusE = /* @__PURE__ */ function(OperationStatusE) {
+	OperationStatusE[OperationStatusE["OPERATIONSTATUS_OK"] = 0] = "OPERATIONSTATUS_OK";
+	OperationStatusE[OperationStatusE["OPERATIONSTATUS_WAIT"] = 1] = "OPERATIONSTATUS_WAIT";
+	OperationStatusE[OperationStatusE["OPERATIONSTATUS_ERROR"] = 2] = "OPERATIONSTATUS_ERROR";
+	OperationStatusE[OperationStatusE["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return OperationStatusE;
+}({});
+function operationStatusEFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "OPERATIONSTATUS_OK": return 0;
+		case 1:
+		case "OPERATIONSTATUS_WAIT": return 1;
+		case 2:
+		case "OPERATIONSTATUS_ERROR": return 2;
+		default: return -1;
+	}
+}
+function operationStatusEToJSON(object) {
+	switch (object) {
+		case 0: return "OPERATIONSTATUS_OK";
+		case 1: return "OPERATIONSTATUS_WAIT";
+		case 2: return "OPERATIONSTATUS_ERROR";
+		default: return "UNRECOGNIZED";
+	}
+}
+let MessageFaultE = /* @__PURE__ */ function(MessageFaultE) {
+	/** MESSAGEFAULT_ERROR_NONE - Request succeeded. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_NONE"] = 0] = "MESSAGEFAULT_ERROR_NONE";
+	/** MESSAGEFAULT_ERROR_BUSY - Required vehicle subsystem is busy. Try again. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_BUSY"] = 1] = "MESSAGEFAULT_ERROR_BUSY";
+	/** MESSAGEFAULT_ERROR_TIMEOUT - Vehicle subsystem did not respond. Try again. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_TIMEOUT"] = 2] = "MESSAGEFAULT_ERROR_TIMEOUT";
+	/** MESSAGEFAULT_ERROR_UNKNOWN_KEY_ID - Vehicle did not recognize the key used to authorize command. Make sure your key is paired with the vehicle. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_UNKNOWN_KEY_ID"] = 3] = "MESSAGEFAULT_ERROR_UNKNOWN_KEY_ID";
+	/** MESSAGEFAULT_ERROR_INACTIVE_KEY - Key used to authorize command has been disabled. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INACTIVE_KEY"] = 4] = "MESSAGEFAULT_ERROR_INACTIVE_KEY";
+	/** MESSAGEFAULT_ERROR_INVALID_SIGNATURE - Command signature/MAC is incorrect. Use included session info to update session and try again. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INVALID_SIGNATURE"] = 5] = "MESSAGEFAULT_ERROR_INVALID_SIGNATURE";
+	/** MESSAGEFAULT_ERROR_INVALID_TOKEN_OR_COUNTER - Command anti-replay counter has been used before. Use included session info to update session and try again. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INVALID_TOKEN_OR_COUNTER"] = 6] = "MESSAGEFAULT_ERROR_INVALID_TOKEN_OR_COUNTER";
+	/** MESSAGEFAULT_ERROR_INSUFFICIENT_PRIVILEGES - User is not authorized to execute command. This can be because of the role or because of vehicle state. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INSUFFICIENT_PRIVILEGES"] = 7] = "MESSAGEFAULT_ERROR_INSUFFICIENT_PRIVILEGES";
+	/** MESSAGEFAULT_ERROR_INVALID_DOMAINS - Command was malformed or addressed to an unrecognized vehicle system. May indicate client error or older vehicle firmware. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INVALID_DOMAINS"] = 8] = "MESSAGEFAULT_ERROR_INVALID_DOMAINS";
+	/** MESSAGEFAULT_ERROR_INVALID_COMMAND - Unrecognized command. May indicate client error or unsupported vehicle firmware. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INVALID_COMMAND"] = 9] = "MESSAGEFAULT_ERROR_INVALID_COMMAND";
+	/** MESSAGEFAULT_ERROR_DECODING - Could not parse command. Indicates client error. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_DECODING"] = 10] = "MESSAGEFAULT_ERROR_DECODING";
+	/** MESSAGEFAULT_ERROR_INTERNAL - Internal vehicle error. Try again. Most commonly encountered when the vehicle has not finished booting. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INTERNAL"] = 11] = "MESSAGEFAULT_ERROR_INTERNAL";
+	/** MESSAGEFAULT_ERROR_WRONG_PERSONALIZATION - Command sent to wrong VIN. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_WRONG_PERSONALIZATION"] = 12] = "MESSAGEFAULT_ERROR_WRONG_PERSONALIZATION";
+	/** MESSAGEFAULT_ERROR_BAD_PARAMETER - Command was malformed or used a deprecated parameter. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_BAD_PARAMETER"] = 13] = "MESSAGEFAULT_ERROR_BAD_PARAMETER";
+	/** MESSAGEFAULT_ERROR_KEYCHAIN_IS_FULL - Vehicle's keychain is full. You must delete a key before you can add another. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_KEYCHAIN_IS_FULL"] = 14] = "MESSAGEFAULT_ERROR_KEYCHAIN_IS_FULL";
+	/** MESSAGEFAULT_ERROR_INCORRECT_EPOCH - Session ID mismatch. Use included session info to update session and try again. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INCORRECT_EPOCH"] = 15] = "MESSAGEFAULT_ERROR_INCORRECT_EPOCH";
+	/** MESSAGEFAULT_ERROR_IV_INCORRECT_LENGTH - Initialization Value length is incorrect (AES-GCM must use 12-byte IVs). Indicates a client programming error. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_IV_INCORRECT_LENGTH"] = 16] = "MESSAGEFAULT_ERROR_IV_INCORRECT_LENGTH";
+	/** MESSAGEFAULT_ERROR_TIME_EXPIRED - Command expired. Use included session info to determine if clocks have desynchronized and try again. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_TIME_EXPIRED"] = 17] = "MESSAGEFAULT_ERROR_TIME_EXPIRED";
+	/** MESSAGEFAULT_ERROR_NOT_PROVISIONED_WITH_IDENTITY - Vehicle has not been provisioned with a VIN and may require service. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_NOT_PROVISIONED_WITH_IDENTITY"] = 18] = "MESSAGEFAULT_ERROR_NOT_PROVISIONED_WITH_IDENTITY";
+	/** MESSAGEFAULT_ERROR_COULD_NOT_HASH_METADATA - Internal vehicle error. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_COULD_NOT_HASH_METADATA"] = 19] = "MESSAGEFAULT_ERROR_COULD_NOT_HASH_METADATA";
+	/** MESSAGEFAULT_ERROR_TIME_TO_LIVE_TOO_LONG - Vehicle rejected command because its expiration time was too far in the future. This is a security precaution. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_TIME_TO_LIVE_TOO_LONG"] = 20] = "MESSAGEFAULT_ERROR_TIME_TO_LIVE_TOO_LONG";
+	/** MESSAGEFAULT_ERROR_REMOTE_ACCESS_DISABLED - The vehicle owner has disabled Mobile access. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_REMOTE_ACCESS_DISABLED"] = 21] = "MESSAGEFAULT_ERROR_REMOTE_ACCESS_DISABLED";
+	/** MESSAGEFAULT_ERROR_REMOTE_SERVICE_ACCESS_DISABLED - The command was authorized with a Service key, but the vehicle has not been configured to permit remote service commands. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_REMOTE_SERVICE_ACCESS_DISABLED"] = 22] = "MESSAGEFAULT_ERROR_REMOTE_SERVICE_ACCESS_DISABLED";
+	/** MESSAGEFAULT_ERROR_COMMAND_REQUIRES_ACCOUNT_CREDENTIALS - The command requires proof of Tesla account credentials but was not sent over a channel that provides this proof. Resend the command using Fleet API. */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_COMMAND_REQUIRES_ACCOUNT_CREDENTIALS"] = 23] = "MESSAGEFAULT_ERROR_COMMAND_REQUIRES_ACCOUNT_CREDENTIALS";
+	/** MESSAGEFAULT_ERROR_REQUEST_MTU_EXCEEDED - Client sent a request with a field that exceeds MTU */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_REQUEST_MTU_EXCEEDED"] = 24] = "MESSAGEFAULT_ERROR_REQUEST_MTU_EXCEEDED";
+	/** MESSAGEFAULT_ERROR_RESPONSE_MTU_EXCEEDED - Client's request was received, but response size exceeded MTU */
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_RESPONSE_MTU_EXCEEDED"] = 25] = "MESSAGEFAULT_ERROR_RESPONSE_MTU_EXCEEDED";
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_REPEATED_COUNTER"] = 26] = "MESSAGEFAULT_ERROR_REPEATED_COUNTER";
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_INVALID_KEY_HANDLE"] = 27] = "MESSAGEFAULT_ERROR_INVALID_KEY_HANDLE";
+	MessageFaultE[MessageFaultE["MESSAGEFAULT_ERROR_REQUIRES_RESPONSE_ENCRYPTION"] = 28] = "MESSAGEFAULT_ERROR_REQUIRES_RESPONSE_ENCRYPTION";
+	MessageFaultE[MessageFaultE["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return MessageFaultE;
+}({});
+function messageFaultEFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "MESSAGEFAULT_ERROR_NONE": return 0;
+		case 1:
+		case "MESSAGEFAULT_ERROR_BUSY": return 1;
+		case 2:
+		case "MESSAGEFAULT_ERROR_TIMEOUT": return 2;
+		case 3:
+		case "MESSAGEFAULT_ERROR_UNKNOWN_KEY_ID": return 3;
+		case 4:
+		case "MESSAGEFAULT_ERROR_INACTIVE_KEY": return 4;
+		case 5:
+		case "MESSAGEFAULT_ERROR_INVALID_SIGNATURE": return 5;
+		case 6:
+		case "MESSAGEFAULT_ERROR_INVALID_TOKEN_OR_COUNTER": return 6;
+		case 7:
+		case "MESSAGEFAULT_ERROR_INSUFFICIENT_PRIVILEGES": return 7;
+		case 8:
+		case "MESSAGEFAULT_ERROR_INVALID_DOMAINS": return 8;
+		case 9:
+		case "MESSAGEFAULT_ERROR_INVALID_COMMAND": return 9;
+		case 10:
+		case "MESSAGEFAULT_ERROR_DECODING": return 10;
+		case 11:
+		case "MESSAGEFAULT_ERROR_INTERNAL": return 11;
+		case 12:
+		case "MESSAGEFAULT_ERROR_WRONG_PERSONALIZATION": return 12;
+		case 13:
+		case "MESSAGEFAULT_ERROR_BAD_PARAMETER": return 13;
+		case 14:
+		case "MESSAGEFAULT_ERROR_KEYCHAIN_IS_FULL": return 14;
+		case 15:
+		case "MESSAGEFAULT_ERROR_INCORRECT_EPOCH": return 15;
+		case 16:
+		case "MESSAGEFAULT_ERROR_IV_INCORRECT_LENGTH": return 16;
+		case 17:
+		case "MESSAGEFAULT_ERROR_TIME_EXPIRED": return 17;
+		case 18:
+		case "MESSAGEFAULT_ERROR_NOT_PROVISIONED_WITH_IDENTITY": return 18;
+		case 19:
+		case "MESSAGEFAULT_ERROR_COULD_NOT_HASH_METADATA": return 19;
+		case 20:
+		case "MESSAGEFAULT_ERROR_TIME_TO_LIVE_TOO_LONG": return 20;
+		case 21:
+		case "MESSAGEFAULT_ERROR_REMOTE_ACCESS_DISABLED": return 21;
+		case 22:
+		case "MESSAGEFAULT_ERROR_REMOTE_SERVICE_ACCESS_DISABLED": return 22;
+		case 23:
+		case "MESSAGEFAULT_ERROR_COMMAND_REQUIRES_ACCOUNT_CREDENTIALS": return 23;
+		case 24:
+		case "MESSAGEFAULT_ERROR_REQUEST_MTU_EXCEEDED": return 24;
+		case 25:
+		case "MESSAGEFAULT_ERROR_RESPONSE_MTU_EXCEEDED": return 25;
+		case 26:
+		case "MESSAGEFAULT_ERROR_REPEATED_COUNTER": return 26;
+		case 27:
+		case "MESSAGEFAULT_ERROR_INVALID_KEY_HANDLE": return 27;
+		case 28:
+		case "MESSAGEFAULT_ERROR_REQUIRES_RESPONSE_ENCRYPTION": return 28;
+		default: return -1;
+	}
+}
+function messageFaultEToJSON(object) {
+	switch (object) {
+		case 0: return "MESSAGEFAULT_ERROR_NONE";
+		case 1: return "MESSAGEFAULT_ERROR_BUSY";
+		case 2: return "MESSAGEFAULT_ERROR_TIMEOUT";
+		case 3: return "MESSAGEFAULT_ERROR_UNKNOWN_KEY_ID";
+		case 4: return "MESSAGEFAULT_ERROR_INACTIVE_KEY";
+		case 5: return "MESSAGEFAULT_ERROR_INVALID_SIGNATURE";
+		case 6: return "MESSAGEFAULT_ERROR_INVALID_TOKEN_OR_COUNTER";
+		case 7: return "MESSAGEFAULT_ERROR_INSUFFICIENT_PRIVILEGES";
+		case 8: return "MESSAGEFAULT_ERROR_INVALID_DOMAINS";
+		case 9: return "MESSAGEFAULT_ERROR_INVALID_COMMAND";
+		case 10: return "MESSAGEFAULT_ERROR_DECODING";
+		case 11: return "MESSAGEFAULT_ERROR_INTERNAL";
+		case 12: return "MESSAGEFAULT_ERROR_WRONG_PERSONALIZATION";
+		case 13: return "MESSAGEFAULT_ERROR_BAD_PARAMETER";
+		case 14: return "MESSAGEFAULT_ERROR_KEYCHAIN_IS_FULL";
+		case 15: return "MESSAGEFAULT_ERROR_INCORRECT_EPOCH";
+		case 16: return "MESSAGEFAULT_ERROR_IV_INCORRECT_LENGTH";
+		case 17: return "MESSAGEFAULT_ERROR_TIME_EXPIRED";
+		case 18: return "MESSAGEFAULT_ERROR_NOT_PROVISIONED_WITH_IDENTITY";
+		case 19: return "MESSAGEFAULT_ERROR_COULD_NOT_HASH_METADATA";
+		case 20: return "MESSAGEFAULT_ERROR_TIME_TO_LIVE_TOO_LONG";
+		case 21: return "MESSAGEFAULT_ERROR_REMOTE_ACCESS_DISABLED";
+		case 22: return "MESSAGEFAULT_ERROR_REMOTE_SERVICE_ACCESS_DISABLED";
+		case 23: return "MESSAGEFAULT_ERROR_COMMAND_REQUIRES_ACCOUNT_CREDENTIALS";
+		case 24: return "MESSAGEFAULT_ERROR_REQUEST_MTU_EXCEEDED";
+		case 25: return "MESSAGEFAULT_ERROR_RESPONSE_MTU_EXCEEDED";
+		case 26: return "MESSAGEFAULT_ERROR_REPEATED_COUNTER";
+		case 27: return "MESSAGEFAULT_ERROR_INVALID_KEY_HANDLE";
+		case 28: return "MESSAGEFAULT_ERROR_REQUIRES_RESPONSE_ENCRYPTION";
+		default: return "UNRECOGNIZED";
+	}
+}
+let Flags = /* @__PURE__ */ function(Flags) {
+	Flags[Flags["FLAG_USER_COMMAND"] = 0] = "FLAG_USER_COMMAND";
+	Flags[Flags["FLAG_ENCRYPT_RESPONSE"] = 1] = "FLAG_ENCRYPT_RESPONSE";
+	Flags[Flags["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return Flags;
+}({});
+function flagsFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "FLAG_USER_COMMAND": return 0;
+		case 1:
+		case "FLAG_ENCRYPT_RESPONSE": return 1;
+		default: return -1;
+	}
+}
+function flagsToJSON(object) {
+	switch (object) {
+		case 0: return "FLAG_USER_COMMAND";
+		case 1: return "FLAG_ENCRYPT_RESPONSE";
+		default: return "UNRECOGNIZED";
+	}
+}
+function createBaseDestination() {
+	return {
+		domain: void 0,
+		routingAddress: void 0
+	};
+}
+const Destination = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.domain !== void 0) writer.uint32(8).int32(message.domain);
+		if (message.routingAddress !== void 0) writer.uint32(18).bytes(message.routingAddress);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseDestination();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.domain = reader.int32();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.routingAddress = reader.bytes();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			domain: isSet(object.domain) ? domainFromJSON(object.domain) : void 0,
+			routingAddress: isSet(object.routingAddress) ? bytesFromBase64(object.routingAddress) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.domain !== void 0) obj.domain = domainToJSON(message.domain);
+		if (message.routingAddress !== void 0) obj.routingAddress = base64FromBytes(message.routingAddress);
+		return obj;
+	},
+	create(base) {
+		return Destination.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseDestination();
+		message.domain = object.domain ?? void 0;
+		message.routingAddress = object.routingAddress ?? void 0;
+		return message;
+	}
+};
+function createBaseMessageStatus() {
+	return {
+		operationStatus: 0,
+		signedMessageFault: 0
+	};
+}
+const MessageStatus = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.operationStatus !== 0) writer.uint32(8).int32(message.operationStatus);
+		if (message.signedMessageFault !== 0) writer.uint32(16).int32(message.signedMessageFault);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseMessageStatus();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.operationStatus = reader.int32();
+					continue;
+				case 2:
+					if (tag !== 16) break;
+					message.signedMessageFault = reader.int32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			operationStatus: isSet(object.operationStatus) ? operationStatusEFromJSON(object.operationStatus) : 0,
+			signedMessageFault: isSet(object.signedMessageFault) ? messageFaultEFromJSON(object.signedMessageFault) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.operationStatus !== void 0) obj.operationStatus = operationStatusEToJSON(message.operationStatus);
+		if (message.signedMessageFault !== void 0) obj.signedMessageFault = messageFaultEToJSON(message.signedMessageFault);
+		return obj;
+	},
+	create(base) {
+		return MessageStatus.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseMessageStatus();
+		message.operationStatus = object.operationStatus ?? 0;
+		message.signedMessageFault = object.signedMessageFault ?? 0;
+		return message;
+	}
+};
+function createBaseSessionInfoRequest() {
+	return {
+		publicKey: /* @__PURE__ */ new Uint8Array(0),
+		challenge: /* @__PURE__ */ new Uint8Array(0)
+	};
+}
+const SessionInfoRequest = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.publicKey.length !== 0) writer.uint32(10).bytes(message.publicKey);
+		if (message.challenge.length !== 0) writer.uint32(18).bytes(message.challenge);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseSessionInfoRequest();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 10) break;
+					message.publicKey = reader.bytes();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.challenge = reader.bytes();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			publicKey: isSet(object.publicKey) ? bytesFromBase64(object.publicKey) : /* @__PURE__ */ new Uint8Array(0),
+			challenge: isSet(object.challenge) ? bytesFromBase64(object.challenge) : /* @__PURE__ */ new Uint8Array(0)
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.publicKey !== void 0) obj.publicKey = base64FromBytes(message.publicKey);
+		if (message.challenge !== void 0) obj.challenge = base64FromBytes(message.challenge);
+		return obj;
+	},
+	create(base) {
+		return SessionInfoRequest.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseSessionInfoRequest();
+		message.publicKey = object.publicKey ?? /* @__PURE__ */ new Uint8Array(0);
+		message.challenge = object.challenge ?? /* @__PURE__ */ new Uint8Array(0);
+		return message;
+	}
+};
+function createBaseRoutableMessage() {
+	return {
+		toDestination: void 0,
+		fromDestination: void 0,
+		protobufMessageAsBytes: void 0,
+		sessionInfoRequest: void 0,
+		sessionInfo: void 0,
+		signatureData: void 0,
+		signedMessageStatus: void 0,
+		requestUuid: /* @__PURE__ */ new Uint8Array(0),
+		uuid: /* @__PURE__ */ new Uint8Array(0),
+		flags: 0
+	};
+}
+const RoutableMessage = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.toDestination !== void 0) Destination.encode(message.toDestination, writer.uint32(50).fork()).join();
+		if (message.fromDestination !== void 0) Destination.encode(message.fromDestination, writer.uint32(58).fork()).join();
+		if (message.protobufMessageAsBytes !== void 0) writer.uint32(82).bytes(message.protobufMessageAsBytes);
+		if (message.sessionInfoRequest !== void 0) SessionInfoRequest.encode(message.sessionInfoRequest, writer.uint32(114).fork()).join();
+		if (message.sessionInfo !== void 0) writer.uint32(122).bytes(message.sessionInfo);
+		if (message.signatureData !== void 0) SignatureData.encode(message.signatureData, writer.uint32(106).fork()).join();
+		if (message.signedMessageStatus !== void 0) MessageStatus.encode(message.signedMessageStatus, writer.uint32(98).fork()).join();
+		if (message.requestUuid.length !== 0) writer.uint32(402).bytes(message.requestUuid);
+		if (message.uuid.length !== 0) writer.uint32(410).bytes(message.uuid);
+		if (message.flags !== 0) writer.uint32(416).uint32(message.flags);
+		return writer;
+	},
+	decode(input, length) {
+		const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+		const end = length === void 0 ? reader.len : reader.pos + length;
+		const message = createBaseRoutableMessage();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 6:
+					if (tag !== 50) break;
+					message.toDestination = Destination.decode(reader, reader.uint32());
+					continue;
+				case 7:
+					if (tag !== 58) break;
+					message.fromDestination = Destination.decode(reader, reader.uint32());
+					continue;
+				case 10:
+					if (tag !== 82) break;
+					message.protobufMessageAsBytes = reader.bytes();
+					continue;
+				case 14:
+					if (tag !== 114) break;
+					message.sessionInfoRequest = SessionInfoRequest.decode(reader, reader.uint32());
+					continue;
+				case 15:
+					if (tag !== 122) break;
+					message.sessionInfo = reader.bytes();
+					continue;
+				case 13:
+					if (tag !== 106) break;
+					message.signatureData = SignatureData.decode(reader, reader.uint32());
+					continue;
+				case 12:
+					if (tag !== 98) break;
+					message.signedMessageStatus = MessageStatus.decode(reader, reader.uint32());
+					continue;
+				case 50:
+					if (tag !== 402) break;
+					message.requestUuid = reader.bytes();
+					continue;
+				case 51:
+					if (tag !== 410) break;
+					message.uuid = reader.bytes();
+					continue;
+				case 52:
+					if (tag !== 416) break;
+					message.flags = reader.uint32();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			toDestination: isSet(object.toDestination) ? Destination.fromJSON(object.toDestination) : void 0,
+			fromDestination: isSet(object.fromDestination) ? Destination.fromJSON(object.fromDestination) : void 0,
+			protobufMessageAsBytes: isSet(object.protobufMessageAsBytes) ? bytesFromBase64(object.protobufMessageAsBytes) : void 0,
+			sessionInfoRequest: isSet(object.sessionInfoRequest) ? SessionInfoRequest.fromJSON(object.sessionInfoRequest) : void 0,
+			sessionInfo: isSet(object.sessionInfo) ? bytesFromBase64(object.sessionInfo) : void 0,
+			signatureData: isSet(object.signatureData) ? SignatureData.fromJSON(object.signatureData) : void 0,
+			signedMessageStatus: isSet(object.signedMessageStatus) ? MessageStatus.fromJSON(object.signedMessageStatus) : void 0,
+			requestUuid: isSet(object.requestUuid) ? bytesFromBase64(object.requestUuid) : /* @__PURE__ */ new Uint8Array(0),
+			uuid: isSet(object.uuid) ? bytesFromBase64(object.uuid) : /* @__PURE__ */ new Uint8Array(0),
+			flags: isSet(object.flags) ? globalThis.Number(object.flags) : 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.toDestination !== void 0) obj.toDestination = Destination.toJSON(message.toDestination);
+		if (message.fromDestination !== void 0) obj.fromDestination = Destination.toJSON(message.fromDestination);
+		if (message.protobufMessageAsBytes !== void 0) obj.protobufMessageAsBytes = base64FromBytes(message.protobufMessageAsBytes);
+		if (message.sessionInfoRequest !== void 0) obj.sessionInfoRequest = SessionInfoRequest.toJSON(message.sessionInfoRequest);
+		if (message.sessionInfo !== void 0) obj.sessionInfo = base64FromBytes(message.sessionInfo);
+		if (message.signatureData !== void 0) obj.signatureData = SignatureData.toJSON(message.signatureData);
+		if (message.signedMessageStatus !== void 0) obj.signedMessageStatus = MessageStatus.toJSON(message.signedMessageStatus);
+		if (message.requestUuid !== void 0) obj.requestUuid = base64FromBytes(message.requestUuid);
+		if (message.uuid !== void 0) obj.uuid = base64FromBytes(message.uuid);
+		if (message.flags !== void 0) obj.flags = Math.round(message.flags);
+		return obj;
+	},
+	create(base) {
+		return RoutableMessage.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseRoutableMessage();
+		message.toDestination = object.toDestination !== void 0 && object.toDestination !== null ? Destination.fromPartial(object.toDestination) : void 0;
+		message.fromDestination = object.fromDestination !== void 0 && object.fromDestination !== null ? Destination.fromPartial(object.fromDestination) : void 0;
+		message.protobufMessageAsBytes = object.protobufMessageAsBytes ?? void 0;
+		message.sessionInfoRequest = object.sessionInfoRequest !== void 0 && object.sessionInfoRequest !== null ? SessionInfoRequest.fromPartial(object.sessionInfoRequest) : void 0;
+		message.sessionInfo = object.sessionInfo ?? void 0;
+		message.signatureData = object.signatureData !== void 0 && object.signatureData !== null ? SignatureData.fromPartial(object.signatureData) : void 0;
+		message.signedMessageStatus = object.signedMessageStatus !== void 0 && object.signedMessageStatus !== null ? MessageStatus.fromPartial(object.signedMessageStatus) : void 0;
+		message.requestUuid = object.requestUuid ?? /* @__PURE__ */ new Uint8Array(0);
+		message.uuid = object.uuid ?? /* @__PURE__ */ new Uint8Array(0);
+		message.flags = object.flags ?? 0;
+		return message;
+	}
+};
+function bytesFromBase64(b64) {
+	if (globalThis.Buffer) return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+	else {
+		const bin = globalThis.atob(b64);
+		const arr = new Uint8Array(bin.length);
+		for (let i = 0; i < bin.length; ++i) arr[i] = bin.charCodeAt(i);
+		return arr;
+	}
+}
+function base64FromBytes(arr) {
+	if (globalThis.Buffer) return globalThis.Buffer.from(arr).toString("base64");
+	else {
+		const bin = [];
+		arr.forEach((byte) => {
+			bin.push(globalThis.String.fromCharCode(byte));
+		});
+		return globalThis.btoa(bin.join(""));
+	}
+}
+function isSet(value) {
+	return value !== null && value !== void 0;
+}
+//#endregion
+export { Destination, Domain, Flags, MessageFaultE, MessageStatus, OperationStatusE, RoutableMessage, SessionInfoRequest, domainFromJSON, domainToJSON, flagsFromJSON, flagsToJSON, messageFaultEFromJSON, messageFaultEToJSON, operationStatusEFromJSON, operationStatusEToJSON, protobufPackage };