@teslemetry/tesla-protocol 0.1.1

package/dist/energy_device/authorization_types.mjs

@@ -0,0 +1,331 @@
+import { Timestamp } from "./google/protobuf/timestamp.mjs";
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+//#region src/energy_device/authorization_types.ts
+const protobufPackage = "tesla.proto.energy_device.v1";
+/**
+* TESLEMETRY SOURCE-OF-RECORD - no upstream.
+* Provenance: Tesla Energy gateway (TEG) local API, from our own
+* observations and contributions from the community
+*/
+let AuthorizationRole = /* @__PURE__ */ function(AuthorizationRole) {
+	AuthorizationRole[AuthorizationRole["AUTHORIZATION_ROLE_INVALID"] = 0] = "AUTHORIZATION_ROLE_INVALID";
+	AuthorizationRole[AuthorizationRole["AUTHORIZATION_ROLE_CUSTOMER"] = 1] = "AUTHORIZATION_ROLE_CUSTOMER";
+	AuthorizationRole[AuthorizationRole["AUTHORIZATION_ROLE_VEHICLE"] = 2] = "AUTHORIZATION_ROLE_VEHICLE";
+	AuthorizationRole[AuthorizationRole["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return AuthorizationRole;
+}({});
+function authorizationRoleFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "AUTHORIZATION_ROLE_INVALID": return 0;
+		case 1:
+		case "AUTHORIZATION_ROLE_CUSTOMER": return 1;
+		case 2:
+		case "AUTHORIZATION_ROLE_VEHICLE": return 2;
+		default: return -1;
+	}
+}
+function authorizationRoleToJSON(object) {
+	switch (object) {
+		case 0: return "AUTHORIZATION_ROLE_INVALID";
+		case 1: return "AUTHORIZATION_ROLE_CUSTOMER";
+		case 2: return "AUTHORIZATION_ROLE_VEHICLE";
+		default: return "UNRECOGNIZED";
+	}
+}
+let AuthorizedClientType = /* @__PURE__ */ function(AuthorizedClientType) {
+	AuthorizedClientType[AuthorizedClientType["AUTHORIZED_CLIENT_TYPE_INVALID"] = 0] = "AUTHORIZED_CLIENT_TYPE_INVALID";
+	AuthorizedClientType[AuthorizedClientType["AUTHORIZED_CLIENT_TYPE_CUSTOMER_MOBILE_APP"] = 1] = "AUTHORIZED_CLIENT_TYPE_CUSTOMER_MOBILE_APP";
+	AuthorizedClientType[AuthorizedClientType["AUTHORIZED_CLIENT_TYPE_VEHICLE"] = 2] = "AUTHORIZED_CLIENT_TYPE_VEHICLE";
+	AuthorizedClientType[AuthorizedClientType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return AuthorizedClientType;
+}({});
+function authorizedClientTypeFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "AUTHORIZED_CLIENT_TYPE_INVALID": return 0;
+		case 1:
+		case "AUTHORIZED_CLIENT_TYPE_CUSTOMER_MOBILE_APP": return 1;
+		case 2:
+		case "AUTHORIZED_CLIENT_TYPE_VEHICLE": return 2;
+		default: return -1;
+	}
+}
+function authorizedClientTypeToJSON(object) {
+	switch (object) {
+		case 0: return "AUTHORIZED_CLIENT_TYPE_INVALID";
+		case 1: return "AUTHORIZED_CLIENT_TYPE_CUSTOMER_MOBILE_APP";
+		case 2: return "AUTHORIZED_CLIENT_TYPE_VEHICLE";
+		default: return "UNRECOGNIZED";
+	}
+}
+let AuthorizedKeyType = /* @__PURE__ */ function(AuthorizedKeyType) {
+	AuthorizedKeyType[AuthorizedKeyType["AUTHORIZED_KEY_TYPE_INVALID"] = 0] = "AUTHORIZED_KEY_TYPE_INVALID";
+	AuthorizedKeyType[AuthorizedKeyType["AUTHORIZED_KEY_TYPE_RSA"] = 1] = "AUTHORIZED_KEY_TYPE_RSA";
+	AuthorizedKeyType[AuthorizedKeyType["AUTHORIZED_KEY_TYPE_ECC"] = 2] = "AUTHORIZED_KEY_TYPE_ECC";
+	AuthorizedKeyType[AuthorizedKeyType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return AuthorizedKeyType;
+}({});
+function authorizedKeyTypeFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "AUTHORIZED_KEY_TYPE_INVALID": return 0;
+		case 1:
+		case "AUTHORIZED_KEY_TYPE_RSA": return 1;
+		case 2:
+		case "AUTHORIZED_KEY_TYPE_ECC": return 2;
+		default: return -1;
+	}
+}
+function authorizedKeyTypeToJSON(object) {
+	switch (object) {
+		case 0: return "AUTHORIZED_KEY_TYPE_INVALID";
+		case 1: return "AUTHORIZED_KEY_TYPE_RSA";
+		case 2: return "AUTHORIZED_KEY_TYPE_ECC";
+		default: return "UNRECOGNIZED";
+	}
+}
+let AuthorizedState = /* @__PURE__ */ function(AuthorizedState) {
+	AuthorizedState[AuthorizedState["AUTHORIZED_STATE_INVALID"] = 0] = "AUTHORIZED_STATE_INVALID";
+	AuthorizedState[AuthorizedState["AUTHORIZED_STATE_PENDING_VERIFICATION"] = 1] = "AUTHORIZED_STATE_PENDING_VERIFICATION";
+	AuthorizedState[AuthorizedState["AUTHORIZED_STATE_PENDING_VERIFICATION_TIMEOUT"] = 2] = "AUTHORIZED_STATE_PENDING_VERIFICATION_TIMEOUT";
+	AuthorizedState[AuthorizedState["AUTHORIZED_STATE_VERIFIED"] = 3] = "AUTHORIZED_STATE_VERIFIED";
+	AuthorizedState[AuthorizedState["AUTHORIZED_STATE_REMOVED"] = 4] = "AUTHORIZED_STATE_REMOVED";
+	AuthorizedState[AuthorizedState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return AuthorizedState;
+}({});
+function authorizedStateFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "AUTHORIZED_STATE_INVALID": return 0;
+		case 1:
+		case "AUTHORIZED_STATE_PENDING_VERIFICATION": return 1;
+		case 2:
+		case "AUTHORIZED_STATE_PENDING_VERIFICATION_TIMEOUT": return 2;
+		case 3:
+		case "AUTHORIZED_STATE_VERIFIED": return 3;
+		case 4:
+		case "AUTHORIZED_STATE_REMOVED": return 4;
+		default: return -1;
+	}
+}
+function authorizedStateToJSON(object) {
+	switch (object) {
+		case 0: return "AUTHORIZED_STATE_INVALID";
+		case 1: return "AUTHORIZED_STATE_PENDING_VERIFICATION";
+		case 2: return "AUTHORIZED_STATE_PENDING_VERIFICATION_TIMEOUT";
+		case 3: return "AUTHORIZED_STATE_VERIFIED";
+		case 4: return "AUTHORIZED_STATE_REMOVED";
+		default: return "UNRECOGNIZED";
+	}
+}
+let AuthorizedVerificationType = /* @__PURE__ */ function(AuthorizedVerificationType) {
+	AuthorizedVerificationType[AuthorizedVerificationType["AUTHORIZED_VERIFICATION_TYPE_INVALID"] = 0] = "AUTHORIZED_VERIFICATION_TYPE_INVALID";
+	AuthorizedVerificationType[AuthorizedVerificationType["AUTHORIZED_VERIFICATION_TYPE_PRESENCE_PROOF"] = 1] = "AUTHORIZED_VERIFICATION_TYPE_PRESENCE_PROOF";
+	AuthorizedVerificationType[AuthorizedVerificationType["AUTHORIZED_VERIFICATION_TYPE_BLE"] = 2] = "AUTHORIZED_VERIFICATION_TYPE_BLE";
+	AuthorizedVerificationType[AuthorizedVerificationType["AUTHORIZED_VERIFICATION_TYPE_SIGNED"] = 3] = "AUTHORIZED_VERIFICATION_TYPE_SIGNED";
+	AuthorizedVerificationType[AuthorizedVerificationType["AUTHORIZED_VERIFICATION_TYPE_HERMES_COMMAND"] = 4] = "AUTHORIZED_VERIFICATION_TYPE_HERMES_COMMAND";
+	AuthorizedVerificationType[AuthorizedVerificationType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return AuthorizedVerificationType;
+}({});
+function authorizedVerificationTypeFromJSON(object) {
+	switch (object) {
+		case 0:
+		case "AUTHORIZED_VERIFICATION_TYPE_INVALID": return 0;
+		case 1:
+		case "AUTHORIZED_VERIFICATION_TYPE_PRESENCE_PROOF": return 1;
+		case 2:
+		case "AUTHORIZED_VERIFICATION_TYPE_BLE": return 2;
+		case 3:
+		case "AUTHORIZED_VERIFICATION_TYPE_SIGNED": return 3;
+		case 4:
+		case "AUTHORIZED_VERIFICATION_TYPE_HERMES_COMMAND": return 4;
+		default: return -1;
+	}
+}
+function authorizedVerificationTypeToJSON(object) {
+	switch (object) {
+		case 0: return "AUTHORIZED_VERIFICATION_TYPE_INVALID";
+		case 1: return "AUTHORIZED_VERIFICATION_TYPE_PRESENCE_PROOF";
+		case 2: return "AUTHORIZED_VERIFICATION_TYPE_BLE";
+		case 3: return "AUTHORIZED_VERIFICATION_TYPE_SIGNED";
+		case 4: return "AUTHORIZED_VERIFICATION_TYPE_HERMES_COMMAND";
+		default: return "UNRECOGNIZED";
+	}
+}
+function createBaseAuthorizationRecord() {
+	return {
+		type: 0,
+		description: "",
+		keyType: 0,
+		publicKey: /* @__PURE__ */ new Uint8Array(0),
+		roles: [],
+		state: 0,
+		verification: 0,
+		addedTime: void 0,
+		identifier: void 0,
+		authorizedByPublicKey: void 0
+	};
+}
+const AuthorizationRecord = {
+	encode(message, writer = new BinaryWriter()) {
+		if (message.type !== 0) writer.uint32(8).int32(message.type);
+		if (message.description !== "") writer.uint32(18).string(message.description);
+		if (message.keyType !== 0) writer.uint32(24).int32(message.keyType);
+		if (message.publicKey.length !== 0) writer.uint32(34).bytes(message.publicKey);
+		writer.uint32(42).fork();
+		for (const v of message.roles) writer.int32(v);
+		writer.join();
+		if (message.state !== 0) writer.uint32(48).int32(message.state);
+		if (message.verification !== 0) writer.uint32(56).int32(message.verification);
+		if (message.addedTime !== void 0) Timestamp.encode(toTimestamp(message.addedTime), writer.uint32(66).fork()).join();
+		if (message.identifier !== void 0) writer.uint32(74).string(message.identifier);
+		if (message.authorizedByPublicKey !== void 0) writer.uint32(82).bytes(message.authorizedByPublicKey);
+		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 = createBaseAuthorizationRecord();
+		while (reader.pos < end) {
+			const tag = reader.uint32();
+			switch (tag >>> 3) {
+				case 1:
+					if (tag !== 8) break;
+					message.type = reader.int32();
+					continue;
+				case 2:
+					if (tag !== 18) break;
+					message.description = reader.string();
+					continue;
+				case 3:
+					if (tag !== 24) break;
+					message.keyType = reader.int32();
+					continue;
+				case 4:
+					if (tag !== 34) break;
+					message.publicKey = reader.bytes();
+					continue;
+				case 5:
+					if (tag === 40) {
+						message.roles.push(reader.int32());
+						continue;
+					}
+					if (tag === 42) {
+						const end2 = reader.uint32() + reader.pos;
+						while (reader.pos < end2) message.roles.push(reader.int32());
+						continue;
+					}
+					break;
+				case 6:
+					if (tag !== 48) break;
+					message.state = reader.int32();
+					continue;
+				case 7:
+					if (tag !== 56) break;
+					message.verification = reader.int32();
+					continue;
+				case 8:
+					if (tag !== 66) break;
+					message.addedTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+					continue;
+				case 9:
+					if (tag !== 74) break;
+					message.identifier = reader.string();
+					continue;
+				case 10:
+					if (tag !== 82) break;
+					message.authorizedByPublicKey = reader.bytes();
+					continue;
+			}
+			if ((tag & 7) === 4 || tag === 0) break;
+			reader.skip(tag & 7);
+		}
+		return message;
+	},
+	fromJSON(object) {
+		return {
+			type: isSet(object.type) ? authorizedClientTypeFromJSON(object.type) : 0,
+			description: isSet(object.description) ? globalThis.String(object.description) : "",
+			keyType: isSet(object.keyType) ? authorizedKeyTypeFromJSON(object.keyType) : 0,
+			publicKey: isSet(object.publicKey) ? bytesFromBase64(object.publicKey) : /* @__PURE__ */ new Uint8Array(0),
+			roles: globalThis.Array.isArray(object?.roles) ? object.roles.map((e) => authorizationRoleFromJSON(e)) : [],
+			state: isSet(object.state) ? authorizedStateFromJSON(object.state) : 0,
+			verification: isSet(object.verification) ? authorizedVerificationTypeFromJSON(object.verification) : 0,
+			addedTime: isSet(object.addedTime) ? fromJsonTimestamp(object.addedTime) : void 0,
+			identifier: isSet(object.identifier) ? globalThis.String(object.identifier) : void 0,
+			authorizedByPublicKey: isSet(object.authorizedByPublicKey) ? bytesFromBase64(object.authorizedByPublicKey) : void 0
+		};
+	},
+	toJSON(message) {
+		const obj = {};
+		if (message.type !== void 0) obj.type = authorizedClientTypeToJSON(message.type);
+		if (message.description !== void 0) obj.description = message.description;
+		if (message.keyType !== void 0) obj.keyType = authorizedKeyTypeToJSON(message.keyType);
+		if (message.publicKey !== void 0) obj.publicKey = base64FromBytes(message.publicKey);
+		if (message.roles?.length) obj.roles = message.roles.map((e) => authorizationRoleToJSON(e));
+		if (message.state !== void 0) obj.state = authorizedStateToJSON(message.state);
+		if (message.verification !== void 0) obj.verification = authorizedVerificationTypeToJSON(message.verification);
+		if (message.addedTime !== void 0) obj.addedTime = message.addedTime.toISOString();
+		if (message.identifier !== void 0) obj.identifier = message.identifier;
+		if (message.authorizedByPublicKey !== void 0) obj.authorizedByPublicKey = base64FromBytes(message.authorizedByPublicKey);
+		return obj;
+	},
+	create(base) {
+		return AuthorizationRecord.fromPartial(base ?? {});
+	},
+	fromPartial(object) {
+		const message = createBaseAuthorizationRecord();
+		message.type = object.type ?? 0;
+		message.description = object.description ?? "";
+		message.keyType = object.keyType ?? 0;
+		message.publicKey = object.publicKey ?? /* @__PURE__ */ new Uint8Array(0);
+		message.roles = object.roles?.map((e) => e) || [];
+		message.state = object.state ?? 0;
+		message.verification = object.verification ?? 0;
+		message.addedTime = object.addedTime ?? void 0;
+		message.identifier = object.identifier ?? void 0;
+		message.authorizedByPublicKey = object.authorizedByPublicKey ?? void 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 toTimestamp(date) {
+	return {
+		seconds: Math.trunc(date.getTime() / 1e3),
+		nanos: date.getTime() % 1e3 * 1e6
+	};
+}
+function fromTimestamp(t) {
+	let millis = (t.seconds || 0) * 1e3;
+	millis += (t.nanos || 0) / 1e6;
+	return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+	if (o instanceof globalThis.Date) return o;
+	else if (typeof o === "string") return new globalThis.Date(o);
+	else return fromTimestamp(Timestamp.fromJSON(o));
+}
+function isSet(value) {
+	return value !== null && value !== void 0;
+}
+//#endregion
+export { AuthorizationRecord, AuthorizationRole, AuthorizedClientType, AuthorizedKeyType, AuthorizedState, AuthorizedVerificationType, authorizationRoleFromJSON, authorizationRoleToJSON, authorizedClientTypeFromJSON, authorizedClientTypeToJSON, authorizedKeyTypeFromJSON, authorizedKeyTypeToJSON, authorizedStateFromJSON, authorizedStateToJSON, authorizedVerificationTypeFromJSON, authorizedVerificationTypeToJSON, protobufPackage };