tesla-fleet-api 0.4.0 → 0.5.0

package/dist/commands.cjs

@@ -1,7 +1,9 @@
 const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
 const require_const = require("./const.cjs");
 const require_vehiclespecific = require("./vehiclespecific.cjs");
+const require_jws = require("./signing/jws.cjs");
 const require_session = require("./signing/session.cjs");
+const require_log = require("./log.cjs");
 const require_crypto = require("./signing/crypto.cjs");
 const require_exceptions = require("./exceptions.cjs");
 let crypto = require("crypto");
@@ -39,10 +41,13 @@ const SeatHeaterLevels = [
 	"seatHeaterMed",
 	"seatHeaterHigh"
 ];
-/** Seat cooling and auto-climate only cover the front seats on the wire protocol. */
+/**
+* Keyed by the REST `seat_position`, which Tesla's vehicle-command proxy reads
+* as the proto enum value (1 front left, 2 front right), not the 0-based `Seats`.
+*/
 const SeatCoolerPositions = {
-	[require_const.Seats.FRONT_LEFT]: _teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerPositionE.HvacSeatCoolerPosition_FrontLeft,
-	[require_const.Seats.FRONT_RIGHT]: _teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerPositionE.HvacSeatCoolerPosition_FrontRight
+	[require_const.AutoSeat.FRONT_LEFT]: _teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerPositionE.HvacSeatCoolerPosition_FrontLeft,
+	[require_const.AutoSeat.FRONT_RIGHT]: _teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerPositionE.HvacSeatCoolerPosition_FrontRight
 };
 const SeatCoolerLevels = [
 	_teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerLevelE.HvacSeatCoolerLevel_Off,
@@ -55,11 +60,12 @@ const AutoSeatPositions = {
 	[require_const.AutoSeat.FRONT_LEFT]: _teslemetry_tesla_protocol_command_car_server.AutoSeatClimateAction_AutoSeatPositionE.AutoSeatPosition_FrontLeft,
 	[require_const.AutoSeat.FRONT_RIGHT]: _teslemetry_tesla_protocol_command_car_server.AutoSeatClimateAction_AutoSeatPositionE.AutoSeatPosition_FrontRight
 };
-const StwHeatLevels = [
-	_teslemetry_tesla_protocol_command_common.StwHeatLevel.StwHeatLevel_Off,
-	_teslemetry_tesla_protocol_command_common.StwHeatLevel.StwHeatLevel_Low,
-	_teslemetry_tesla_protocol_command_common.StwHeatLevel.StwHeatLevel_High
-];
+/** Keyed by the REST `Level`, which takes 0, 1 and 3 here: the protocol has no medium steering wheel heat. */
+const StwHeatLevels = {
+	0: _teslemetry_tesla_protocol_command_common.StwHeatLevel.StwHeatLevel_Off,
+	1: _teslemetry_tesla_protocol_command_common.StwHeatLevel.StwHeatLevel_Low,
+	3: _teslemetry_tesla_protocol_command_common.StwHeatLevel.StwHeatLevel_High
+};
 const ClimateKeeperActions = {
 	[require_const.ClimateModes.Off]: _teslemetry_tesla_protocol_command_car_server.HvacClimateKeeperAction_ClimateKeeperActionE.ClimateKeeperAction_Off,
 	[require_const.ClimateModes.Keep]: _teslemetry_tesla_protocol_command_car_server.HvacClimateKeeperAction_ClimateKeeperActionE.ClimateKeeperAction_On,
@@ -81,6 +87,23 @@ const CopActivationTemps = {
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/**
+* The name of a message's populated oneof field, as `WhichOneof` gives it in
+* Python. ts-proto leaves unset oneof members `undefined`; `plainFields` names
+* any fields outside the oneof, which always carry a value.
+*/
+function populatedField(message, plainFields = []) {
+	return Object.entries(message).find(([key, value]) => value !== void 0 && !plainFields.includes(key))?.[0];
+}
+/** A short debug-log name for a VCSEC command: the RKE action name, or the populated field. */
+function vcsec_command_name(command) {
+	if (command.RKEAction !== void 0) return (0, _teslemetry_tesla_protocol_command_vcsec.rKEActionEToJSON)(command.RKEAction);
+	return populatedField(command) ?? "unknown";
+}
+/** A short debug-log name for an infotainment command: the populated `VehicleAction` field. */
+function infotainment_command_name(command) {
+	return (command.vehicleAction && populatedField(command.vehicleAction, ["dropNominalSuccessResponses"])) ?? "unknown";
+}
 function ok(reason = "") {
 	return { response: {
 		result: true,
@@ -94,37 +117,105 @@ function fail(reason) {
 	} };
 }
 /**
+* Day names Tesla's vehicle-command proxy accepts for `days_of_week`, which the
+* REST route takes as a comma-joined string rather than the proto bitmask.
+*/
+const DAY_OF_WEEK_BITS = {
+	SUN: 1,
+	SUNDAY: 1,
+	MON: 2,
+	MONDAY: 2,
+	TUES: 4,
+	TUESDAY: 4,
+	WED: 8,
+	WEDNESDAY: 8,
+	THURS: 16,
+	THURSDAY: 16,
+	FRI: 32,
+	FRIDAY: 32,
+	SAT: 64,
+	SATURDAY: 64,
+	ALL: 127,
+	WEEKDAYS: 62
+};
+/**
+* Convert a bitmask or comma-joined day names (e.g. `"Mon,Wed"`, `"All"`) to the proto bitmask.
+* @throws Error for an unknown day name.
+*/
+function days_of_week_mask(days_of_week) {
+	if (typeof days_of_week === "number") return Math.trunc(days_of_week);
+	if (/^\d+$/.test(days_of_week.trim())) return parseInt(days_of_week.trim(), 10);
+	let mask = 0;
+	for (const day of days_of_week.split(",")) {
+		const bit = DAY_OF_WEEK_BITS[day.trim().toUpperCase()];
+		if (bit === void 0) throw new Error(`Invalid day of week: ${day}`);
+		mask |= bit;
+	}
+	return mask;
+}
+/**
 * Transport-agnostic signed-command builder for the Tesla Vehicle Command
 * Protocol: mirrors `python-tesla-fleet-api`'s `Commands` ABC. Every method
-* here builds a `RoutableMessage`, signs it (HMAC-personalized), and
-* dispatches it through the single abstract seam `_send`. A concrete
-* subclass fills that seam for one transport - the cloud `/signed_command`
-* HTTP endpoint (`VehicleSigned`) today, a BLE GATT link in a future story.
+* here builds a `RoutableMessage`, signs it by `authMethod`, and dispatches
+* it through the single abstract seam `_send`. A concrete subclass fills that
+* seam for one transport: the cloud `/signed_command` HTTP endpoint
+* (`VehicleSigned`) today, a BLE GATT link next. The protected members are
+* what such a transport builds on.
 *
-* AES-GCM personalized signing (the BLE-only auth mode) is intentionally out
-* of scope here; see AGENTS.md.
+* `"hmac"` signs a plaintext command. `"aes"` encrypts it with AES-GCM and asks
+* the vehicle to encrypt its reply, which firmware before 2024.38 ignores.
 */
 var Commands = class extends require_vehiclespecific.default {
 	#privateKey;
 	#publicKey;
 	/** Delay between WAIT-retries; overridable so tests don't have to wait for real timers. */
 	retryDelayMs = 2e3;
+	/** Session-info requests sent before a handshake gives up on replies that fail authentication. */
+	handshakeAttempts = 3;
+	/** Delay between those requests. */
+	handshakeRetryDelayMs = 1e3;
+	/** How `buildMessage` signs a command. */
+	authMethod = "hmac";
+	/** One random routing address per instance: replies addressed to it are ours. */
 	fromDestination;
 	sessions;
+	/**
+	* @param parent
+	* @param vin
+	* @param privateKey Raw 32-byte P-256 scalar. `undefined` falls back to the parent's key, and throws if there is none. `false` disables signing, for a passive listener that never sends a command: any handshake then raises `SigningDisabled`.
+	* @param publicKey Uncompressed P-256 point. Derived from `privateKey` if omitted.
+	*/
 	constructor(parent, vin, privateKey, publicKey) {
 		super(parent, vin);
 		if (vin.length !== 17) throw new Error(`Signed commands require a 17-character VIN, got ${vin.length} characters.`);
-		const resolvedPrivateKey = privateKey ?? parent.private_key;
-		if (!resolvedPrivateKey) throw new Error("No private key provided for signed commands.");
-		this.#privateKey = resolvedPrivateKey;
-		this.#publicKey = publicKey ?? require_crypto.publicKeyFor(this.#privateKey);
+		if (privateKey === false) this.#privateKey = null;
+		else {
+			const resolvedPrivateKey = privateKey ?? parent.private_key ?? parent.parent.private_key;
+			if (!resolvedPrivateKey) throw new Error("No private key provided for signed commands.");
+			this.#privateKey = resolvedPrivateKey;
+		}
+		this.#publicKey = publicKey ?? (this.#privateKey ? require_crypto.publicKeyFor(this.#privateKey) : Buffer.alloc(0));
 		this.fromDestination = crypto.default.randomBytes(16);
-		const deriveKey = (vehiclePublicKey) => require_crypto.deriveSharedKey(this.#privateKey, vehiclePublicKey);
+		const deriveKey = (vehiclePublicKey) => this.shared_key(vehiclePublicKey);
 		this.sessions = {
 			[_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY]: new require_session.Session(_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY, deriveKey),
 			[_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_INFOTAINMENT]: new require_session.Session(_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_INFOTAINMENT, deriveKey)
 		};
 	}
+	/** The uncompressed public key this instance signs with. Empty when signing is disabled. */
+	get publicKey() {
+		return this.#publicKey;
+	}
+	/** Derive the 16-byte shared key used for signed-command session encryption. */
+	shared_key(vehicleKey) {
+		if (this.#privateKey === null) throw new require_exceptions.SigningDisabled();
+		return require_crypto.deriveSharedKey(this.#privateKey, vehicleKey);
+	}
+	/** A Tesla.SS256 JWS over a Fleet Telemetry config, signed here so the key never leaves this class. */
+	signFleetTelemetryConfig(config) {
+		if (this.#privateKey === null) throw new require_exceptions.SigningDisabled();
+		return require_jws.sign_fleet_telemetry_config(this.#privateKey, config);
+	}
 	sessionFor(domain) {
 		const session = this.sessions[domain];
 		if (!session) throw new Error(`No signed-command session configured for domain ${domain}.`);
@@ -133,26 +224,49 @@ var Commands = class extends require_vehiclespecific.default {
 	/**
 	* Absorb session info piggy-backed on any signed-command reply and raise
 	* on a whitelist rejection or a terminal message fault. Every concrete
-	* `_send` must call this on the reply - passing the `uuid` of the request
-	* it just sent - before returning it.
+	* `_send` must call this on the reply - passing the `uuid` and destination
+	* domain of the request it just sent - before returning it. The session comes
+	* from that request: a reply's own `fromDestination` is unauthenticated, so it
+	* can only be checked against the request, never select a session.
 	*
 	* A `SessionInfo` is untrusted wire data until its `session_info_tag` is
-	* verified: the tag is an HMAC over the exact bytes received, keyed by a
-	* key derived from the *candidate* vehicle public key carried inside that
-	* same SessionInfo, and bound to this request's `uuid` as a challenge (so
-	* a captured older reply can't be replayed against a newer request). Only
-	* once that tag checks out do we act on anything the message claims -
+	* verified: the tag is an HMAC over the exact bytes received, bound to this
+	* request's `uuid` as a challenge (so a captured older reply can't be
+	* replayed against a newer request). It is keyed by the session's stored
+	* key. Only at first contact, when there is none, is that key derived from
+	* the public key in the reply, which is trust on first use; see `Session`.
+	* Only once that tag checks out do we act on anything the message claims -
 	* including its own whitelist-status field - and even then `Session.commit`
 	* still refuses a clock time that regresses within the same epoch.
+	*
+	* The one exception is an empty public key: no shared key can be derived
+	* from it to verify a tag. An unpaired key has no session, so
+	* key-not-on-whitelist is the only real reply that omits the key, and that
+	* one status is accepted unauthenticated. Any other status with no key is
+	* malformed.
 	*/
-	validateAndUpdateSession(resp, requestUuid) {
+	validate_msg(resp, requestUuid, requestDomain) {
 		if (resp.sessionInfo && resp.sessionInfo.length > 0) {
-			const domain = resp.fromDestination?.domain;
-			const session = domain !== void 0 ? this.sessions[domain] : void 0;
-			if (!session) throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply is missing a recognized source domain.");
+			const session = requestDomain !== void 0 ? this.sessions[requestDomain] : void 0;
+			if (!session || resp.fromDestination?.domain !== requestDomain) throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply is not from the domain the request went to; discarded.");
 			if (resp.requestUuid && resp.requestUuid.length > 0 && !requestUuid.equals(Buffer.from(resp.requestUuid))) throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply does not match an outstanding request; discarded.");
-			const info = _teslemetry_tesla_protocol_command_signatures.SessionInfo.decode(resp.sessionInfo);
-			const keys = session.keysFor(Buffer.from(info.publicKey));
+			let info;
+			try {
+				info = _teslemetry_tesla_protocol_command_signatures.SessionInfo.decode(resp.sessionInfo);
+			} catch (cause) {
+				throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply could not be decoded.", null, { cause });
+			}
+			if (info.publicKey.length === 0) {
+				if (info.status === _teslemetry_tesla_protocol_command_signatures.SessionInfoStatus.SESSION_INFO_STATUS_KEY_NOT_ON_WHITELIST) throw new require_exceptions.NotOnWhitelistFault();
+				throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply has no public key.");
+			}
+			let keys;
+			try {
+				keys = session.trustedKeys(Buffer.from(info.publicKey));
+			} catch (cause) {
+				if (cause instanceof require_exceptions.SessionInfoAuthenticationFault || cause instanceof require_exceptions.SigningDisabled) throw cause;
+				throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply has an invalid public key.", null, { cause });
+			}
 			const tag = resp.signatureData?.sessionInfoTag?.tag;
 			if (!tag || tag.length === 0) throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply is missing its authentication tag; discarded.");
 			const metadata = Buffer.concat([
@@ -176,14 +290,61 @@ var Commands = class extends require_vehiclespecific.default {
 		const fault = resp.signedMessageStatus?.signedMessageFault;
 		if (fault !== void 0 && fault !== _teslemetry_tesla_protocol_command_universal_message.MessageFaultE.MESSAGEFAULT_ERROR_NONE) throw new (require_exceptions.MESSAGE_FAULTS[fault] ?? require_exceptions.TeslaFleetMessageFault)({ fault });
 	}
-	async handshake(domain) {
-		const msg = _teslemetry_tesla_protocol_command_universal_message.RoutableMessage.create({
+	/** The unsigned session-info request that opens a domain session. */
+	sessionInfoRequest(domain) {
+		return _teslemetry_tesla_protocol_command_universal_message.RoutableMessage.create({
 			toDestination: { domain },
 			fromDestination: { routingAddress: this.fromDestination },
 			sessionInfoRequest: { publicKey: this.#publicKey },
 			uuid: crypto.default.randomBytes(16)
 		});
-		await this._send(msg, "session_info");
+	}
+	/**
+	* Open or refresh a domain session. A reply that fails authentication is
+	* discarded and the unsigned, idempotent request sent again, rather than
+	* failing the handshake on one bad reply. Never trusted either way.
+	*
+	* For VCSEC the caller must hold the session lock; `ensureHandshake` and
+	* `handshakeVehicleSecurity` do.
+	* @returns Whether the session can now sign.
+	* @throws SigningDisabled before anything is sent, when this instance has no key.
+	*/
+	async handshake(domain, options) {
+		if (this.#privateKey === null) throw new require_exceptions.SigningDisabled();
+		for (let attempt = 1;; attempt++) try {
+			await this._send(this.sessionInfoRequest(domain), "session_info", options);
+			return this.sessionFor(domain).ready;
+		} catch (error) {
+			if (!(error instanceof require_exceptions.SessionInfoAuthenticationFault) || attempt >= this.handshakeAttempts) throw error;
+			await sleep(this.handshakeRetryDelayMs);
+		}
+	}
+	/**
+	* Open a domain session unless one is ready, for a subclass that must know
+	* it can sign before it dispatches. Do not call this from inside the VCSEC
+	* session lock, which it takes.
+	*/
+	async ensureHandshake(domain) {
+		const session = this.sessionFor(domain);
+		if (domain !== _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY) {
+			if (!session.ready) await this.handshake(domain);
+			return;
+		}
+		await session.withLock(async () => {
+			if (!session.ready) await this.handshake(domain);
+		});
+	}
+	/** Perform a handshake with the vehicle security domain, even if a session is already established. */
+	async handshakeVehicleSecurity() {
+		await this.sessionFor(_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY).withLock(() => this.handshake(_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY));
+	}
+	/** Perform a handshake with the infotainment domain, even if a session is already established. */
+	async handshakeInfotainment() {
+		await this.handshake(_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_INFOTAINMENT);
+	}
+	/** Sign `command` for `session` by `authMethod`. Assigns a counter, so run it under the session lock. */
+	buildMessage(session, command) {
+		return this.authMethod === "aes" ? this.buildAesMessage(session, command) : this.buildHmacMessage(session, command);
 	}
 	buildHmacMessage(session, command) {
 		const personalized = session.hmacPersonalized();
@@ -224,6 +385,103 @@ var Commands = class extends require_vehiclespecific.default {
 			}
 		});
 	}
+	buildAesMessage(session, command) {
+		const personalized = session.aesGcmPersonalized();
+		if (!session.sharedKey) throw new Error("Session shared key is missing.");
+		const flags = 1 << _teslemetry_tesla_protocol_command_universal_message.Flags.FLAG_ENCRYPT_RESPONSE;
+		const metadata = Buffer.concat([
+			Buffer.from([
+				_teslemetry_tesla_protocol_command_signatures.Tag.TAG_SIGNATURE_TYPE,
+				1,
+				_teslemetry_tesla_protocol_command_signatures.SignatureType.SIGNATURE_TYPE_AES_GCM_PERSONALIZED
+			]),
+			Buffer.from([
+				_teslemetry_tesla_protocol_command_signatures.Tag.TAG_DOMAIN,
+				1,
+				session.domain
+			]),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_PERSONALIZATION, 17]),
+			Buffer.from(this.vin, "ascii"),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_EPOCH, personalized.epoch.length]),
+			Buffer.from(personalized.epoch),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_EXPIRES_AT, 4]),
+			require_crypto.uint32BE(personalized.expiresAt),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_COUNTER, 4]),
+			require_crypto.uint32BE(personalized.counter),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_FLAGS, 4]),
+			require_crypto.uint32BE(flags),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_END])
+		]);
+		const { ciphertext, tag } = require_crypto.aesGcmEncrypt(session.sharedKey, personalized.nonce, command, require_crypto.sha256(metadata));
+		return _teslemetry_tesla_protocol_command_universal_message.RoutableMessage.create({
+			toDestination: { domain: session.domain },
+			fromDestination: { routingAddress: this.fromDestination },
+			protobufMessageAsBytes: ciphertext,
+			uuid: crypto.default.randomBytes(16),
+			flags,
+			signatureData: {
+				signerIdentity: _teslemetry_tesla_protocol_command_signatures.KeyIdentity.create({ publicKey: this.#publicKey }),
+				AESGCMPersonalizedData: {
+					...personalized,
+					tag
+				}
+			}
+		});
+	}
+	/** The authentication method of `request` followed by its tag, which a response's metadata binds to. */
+	requestHash(session, request) {
+		const aes = request.signatureData?.AESGCMPersonalizedData;
+		if (aes) return Buffer.concat([Buffer.from([_teslemetry_tesla_protocol_command_signatures.SignatureType.SIGNATURE_TYPE_AES_GCM_PERSONALIZED]), aes.tag]);
+		const hmac = request.signatureData?.HMACPersonalizedData;
+		if (!hmac) throw new Error("Invalid request signature data.");
+		const hash = Buffer.concat([Buffer.from([_teslemetry_tesla_protocol_command_signatures.SignatureType.SIGNATURE_TYPE_HMAC_PERSONALIZED]), hmac.tag]);
+		return session.domain === _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY ? hash.subarray(0, 17) : hash;
+	}
+	/**
+	* Open an encrypted reply to `request`. A reply with no `AESGCMResponseData`
+	* is plaintext and comes back as it is.
+	*
+	* A reply that fails to open cannot be trusted, and says nothing about
+	* whether the command ran.
+	* @returns The reply with its payload in the clear.
+	* @throws Error when the reply fails to open.
+	* @throws SignedCommandResponseReplayed when this request already saw this response counter.
+	*/
+	decryptResponse(session, request, resp) {
+		const data = resp.signatureData?.AESGCMResponseData;
+		if (!data || resp.protobufMessageAsBytes === void 0) return resp;
+		if (!session.sharedKey) throw new Error("Session shared key is missing.");
+		const requestHash = this.requestHash(session, request);
+		const metadata = Buffer.concat([
+			Buffer.from([
+				_teslemetry_tesla_protocol_command_signatures.Tag.TAG_SIGNATURE_TYPE,
+				1,
+				_teslemetry_tesla_protocol_command_signatures.SignatureType.SIGNATURE_TYPE_AES_GCM_RESPONSE
+			]),
+			Buffer.from([
+				_teslemetry_tesla_protocol_command_signatures.Tag.TAG_DOMAIN,
+				1,
+				resp.fromDestination?.domain ?? _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_BROADCAST
+			]),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_PERSONALIZATION, 17]),
+			Buffer.from(this.vin, "ascii"),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_COUNTER, 4]),
+			require_crypto.uint32BE(data.counter),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_FLAGS, 4]),
+			require_crypto.uint32BE(resp.flags),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_REQUEST_HASH, requestHash.length]),
+			requestHash,
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_FAULT, 4]),
+			require_crypto.uint32BE(resp.signedMessageStatus?.signedMessageFault ?? 0),
+			Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_END])
+		]);
+		const plaintext = require_crypto.aesGcmDecrypt(session.sharedKey, data.nonce, resp.protobufMessageAsBytes, data.tag, require_crypto.sha256(metadata));
+		if (!session.record_response_counter(requestHash, data.counter)) throw new require_exceptions.SignedCommandResponseReplayed();
+		return {
+			...resp,
+			protobufMessageAsBytes: plaintext
+		};
+	}
 	/**
 	* Build, sign, dispatch (with WAIT/epoch-fault retry), and interpret one
 	* domain command.
@@ -236,16 +494,16 @@ var Commands = class extends require_vehiclespecific.default {
 	* most one VCSEC message is ever in flight. Infotainment keeps the
 	* narrower build-only lock, serializing only counter assignment.
 	*/
-	async dispatch(domain, command, expectsData) {
+	async dispatch(domain, command, options = {}) {
 		const session = this.sessionFor(domain);
 		const serializeWholeDispatch = domain === _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY;
 		const run = async () => {
 			if (!session.ready) await this.handshake(domain);
 			for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
-				const msg = serializeWholeDispatch ? this.buildHmacMessage(session, command) : await session.withLock(() => this.buildHmacMessage(session, command));
+				const msg = serializeWholeDispatch ? this.buildMessage(session, command) : await session.withLock(() => this.buildMessage(session, command));
 				let resp;
 				try {
-					resp = await this._send(msg, "protobuf_message_as_bytes", expectsData);
+					resp = await this._send(msg, "protobuf_message_as_bytes", options);
 				} catch (error) {
 					if ((error instanceof require_exceptions.TeslaFleetMessageFaultIncorrectEpoch || error instanceof require_exceptions.TeslaFleetMessageFaultInvalidTokenOrCounter) && attempt < 3) continue;
 					throw error;
@@ -255,7 +513,7 @@ var Commands = class extends require_vehiclespecific.default {
 					await sleep(this.retryDelayMs);
 					continue;
 				}
-				const result = this.interpretResponse(resp);
+				const result = this.interpretResponse(this.decryptResponse(session, msg, resp), options.expectsData ?? true);
 				if (result === "wait") {
 					if (attempt >= 3) return fail("Too many retries");
 					await sleep(this.retryDelayMs);
@@ -267,53 +525,240 @@ var Commands = class extends require_vehiclespecific.default {
 		};
 		return serializeWholeDispatch ? session.withLock(run) : run();
 	}
-	interpretResponse(resp) {
+	interpretResponse(resp, expectsData) {
 		if (!resp.protobufMessageAsBytes || resp.protobufMessageAsBytes.length === 0) return ok();
 		const domain = resp.fromDestination?.domain;
-		if (domain === _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY) return this.interpretVcsecResponse(resp.protobufMessageAsBytes);
+		if (domain === _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY) return this.interpretVcsecResponse(resp.protobufMessageAsBytes, expectsData);
 		if (domain === _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_INFOTAINMENT) return this.interpretInfotainmentResponse(resp.protobufMessageAsBytes);
 		return ok();
 	}
-	interpretVcsecResponse(bytes) {
+	interpretVcsecResponse(bytes, expectsData) {
 		const vcsec = _teslemetry_tesla_protocol_command_vcsec.FromVCSECMessage.decode(bytes);
 		if (vcsec.nominalError) return fail((0, _teslemetry_tesla_protocol_command_errors.genericErrorEToJSON)(vcsec.nominalError.genericError));
-		if (vcsec.vehicleStatus) return ok();
+		if (vcsec.vehicleStatus) return expectsData ? { response: vcsec.vehicleStatus } : ok();
 		if (vcsec.commandStatus) {
-			if (vcsec.commandStatus.operationStatus === _teslemetry_tesla_protocol_command_vcsec.OperationStatusE.OPERATIONSTATUS_OK) return ok();
-			if (vcsec.commandStatus.operationStatus === _teslemetry_tesla_protocol_command_vcsec.OperationStatusE.OPERATIONSTATUS_WAIT) return "wait";
-			if (vcsec.commandStatus.operationStatus === _teslemetry_tesla_protocol_command_vcsec.OperationStatusE.OPERATIONSTATUS_ERROR) {
-				const information = vcsec.commandStatus.signedMessageStatus?.signedMessageInformation;
-				if (information) throw new (require_exceptions.SIGNED_MESSAGE_INFORMATION_FAULTS[information] ?? require_exceptions.SignedMessageInformationFault)({ information: (0, _teslemetry_tesla_protocol_command_vcsec.signedMessageInformationEToJSON)(information) });
+			const status = vcsec.commandStatus;
+			if (status.operationStatus === _teslemetry_tesla_protocol_command_vcsec.OperationStatusE.OPERATIONSTATUS_OK) {
+				this.raiseWhitelistFault(status.whitelistOperationStatus?.whitelistOperationInformation);
+				return ok();
+			}
+			if (status.operationStatus === _teslemetry_tesla_protocol_command_vcsec.OperationStatusE.OPERATIONSTATUS_WAIT) return "wait";
+			if (status.operationStatus === _teslemetry_tesla_protocol_command_vcsec.OperationStatusE.OPERATIONSTATUS_ERROR) {
+				if (status.signedMessageStatus) {
+					const information = status.signedMessageStatus.signedMessageInformation;
+					const cls = require_exceptions.SIGNED_MESSAGE_INFORMATION_FAULTS[information];
+					if (cls) throw new cls({ information: (0, _teslemetry_tesla_protocol_command_vcsec.signedMessageInformationEToJSON)(information) });
+				} else this.raiseWhitelistFault(status.whitelistOperationStatus?.whitelistOperationInformation);
+				return fail((0, _teslemetry_tesla_protocol_command_vcsec.operationStatusEToJSON)(status.operationStatus));
 			}
 		}
 		return ok();
 	}
+	raiseWhitelistFault(information) {
+		if (!information) return;
+		if (information >= require_exceptions.WHITELIST_OPERATION_STATUS.length) throw new require_exceptions.WhitelistOperationStatus(`Unknown whitelist operation failure: ${information}`);
+		const cls = require_exceptions.WHITELIST_OPERATION_STATUS[information];
+		if (cls) throw new cls({ information: (0, _teslemetry_tesla_protocol_command_vcsec.whitelistOperationInformationEToJSON)(information) });
+	}
 	interpretInfotainmentResponse(bytes) {
 		const response = _teslemetry_tesla_protocol_command_car_server.Response.decode(bytes);
-		if (response.ping) return ok(String(response.ping.localTimestamp ?? ""));
+		if (response.ping) return ok(response.ping.localTimestamp?.toISOString() ?? "");
+		if (response.vehicleData) return { response: response.vehicleData };
+		const field = populatedField(response, ["actionStatus"]);
+		const data = field ? { [field]: response[field] } : {};
 		if (response.actionStatus) return { response: {
 			result: response.actionStatus.result === _teslemetry_tesla_protocol_command_car_server.OperationStatusE.OPERATIONSTATUS_OK,
-			reason: response.actionStatus.resultReason?.plainText ?? ""
+			reason: response.actionStatus.resultReason?.plainText ?? "",
+			...data
 		} };
-		return ok();
+		return { response: {
+			result: true,
+			reason: "",
+			...data
+		} };
+	}
+	/** Dispatch one signed command, logging its name, transport and outcome. */
+	async dispatchLogged(name, domain, command, options) {
+		const log = (message) => this.parent.parent._log(message);
+		let result;
+		try {
+			result = await this.dispatch(domain, command, options);
+		} catch (error) {
+			require_log.logRequestError(log, name, this._transport_name, error);
+			throw error;
+		}
+		require_log.logRequestResult(log, name, this._transport_name, result);
+		return result;
+	}
+	/** The data a read asked for. A reply that only reports an outcome carries none. */
+	readData(reply) {
+		if ("result" in reply.response) throw new require_exceptions.InvalidResponse({
+			result: reply.response.result,
+			reason: reply.response.reason
+		});
+		return reply.response;
+	}
+	/** One `getVehicleImageState` read, with the single image its reply must carry. */
+	async readVehicleImage(request) {
+		const data = await this._getInfotainment(_teslemetry_tesla_protocol_command_car_server.Action.create({ vehicleAction: _teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ getVehicleData: _teslemetry_tesla_protocol_command_car_server.GetVehicleData.create({ getVehicleImageState: _teslemetry_tesla_protocol_command_car_server.GetVehicleImageState.create({ imageRequests: [_teslemetry_tesla_protocol_command_car_server.VehicleImageRequest.create(request)] }) }) }) }));
+		const image = data.vehicleImageState?.vehicleImages[0];
+		if (!image) throw new require_exceptions.InvalidResponse({ vehicleImageState: data.vehicleImageState ?? null });
+		return image;
+	}
+	/**
+	* Fetches a rendered vehicle image and returns its assembled bytes. Unlike
+	* any other read it is paged: an `ID` request reports the total size, then
+	* `DATA` requests advance by `chunk_size` until the whole range has arrived.
+	* @param image_type `VehicleImageType`
+	* @param chunk_size Bytes per request. A transport with a small frame needs a smaller value than the default.
+	* @throws Error when `chunk_size` is invalid, before anything is sent, or when the chunks do not add up to the reported size.
+	* @throws InvalidResponse when a reply carries no image.
+	*/
+	async vehicle_image_state(image_type, chunk_size = 16384) {
+		if (!Number.isInteger(chunk_size) || chunk_size <= 0) throw new Error("chunk_size must be a positive integer");
+		const { totalImageSize: totalSize } = await this.readVehicleImage({
+			dataType: _teslemetry_tesla_protocol_command_car_server.VehicleImageRequest_Type.ID,
+			imageType: image_type
+		});
+		const chunks = [];
+		let offset = 0;
+		while (offset < totalSize) {
+			const { assetData } = await this.readVehicleImage({
+				dataType: _teslemetry_tesla_protocol_command_car_server.VehicleImageRequest_Type.DATA,
+				imageType: image_type,
+				chunkRequest: _teslemetry_tesla_protocol_command_car_server.VehicleImageDataChunkRequest.create({
+					chunkOffset: offset,
+					chunkSize: Math.min(chunk_size, totalSize - offset)
+				})
+			});
+			const startOffset = assetData?.startOffset ?? 0;
+			if (startOffset !== offset) throw new Error(`Unexpected vehicle image chunk offset ${startOffset}; expected ${offset}`);
+			const chunk = assetData?.data;
+			if (!chunk || chunk.length === 0) throw new Error(`Vehicle image ended after ${offset} of ${totalSize} bytes`);
+			chunks.push(chunk);
+			offset += chunk.length;
+			if (offset > totalSize) throw new Error(`Vehicle image exceeded declared size of ${totalSize} bytes`);
+		}
+		return Buffer.concat(chunks);
+	}
+	/** Sign and send an actuation: its reply is a bare terminal ack, so `expectsData` is false. */
+	async sendVehicleSecurity(command, options = {}) {
+		return await this.dispatchLogged(vcsec_command_name(command), _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY, Buffer.from(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.encode(command).finish()), {
+			...options,
+			expectsData: false
+		});
+	}
+	/**
+	* Sign and send a read to the Vehicle Security computer.
+	* @throws InvalidResponse when the reply carries no `VehicleStatus`.
+	*/
+	async _getVehicleSecurity(command) {
+		const reply = await this.dispatchLogged(vcsec_command_name(command), _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY, Buffer.from(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.encode(command).finish()));
+		return this.readData(reply);
 	}
-	async sendVehicleSecurity(command) {
-		return this.dispatch(_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY, Buffer.from(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.encode(command).finish()), false);
+	/**
+	* Sign and send a command to the Infotainment computer. Reads go through
+	* `_getInfotainment`. `mutating` is false for a command that cannot change
+	* the vehicle, so a transport can give up on it rather than ask whether it
+	* ran; `ping` is the only one. The cloud transport has no use for it.
+	*/
+	async sendInfotainment(action, { onSubmitted } = {}) {
+		return await this.dispatchLogged(infotainment_command_name(action), _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_INFOTAINMENT, Buffer.from(_teslemetry_tesla_protocol_command_car_server.Action.encode(action).finish()), { onSubmitted });
 	}
-	async sendInfotainment(action) {
-		return this.dispatch(_teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_INFOTAINMENT, Buffer.from(_teslemetry_tesla_protocol_command_car_server.Action.encode(action).finish()), true);
+	/**
+	* Sign and send a read to the Infotainment computer.
+	* @throws InvalidResponse when the reply carries no `VehicleData`.
+	*/
+	async _getInfotainment(action) {
+		const reply = await this.dispatchLogged(infotainment_command_name(action), _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_INFOTAINMENT, Buffer.from(_teslemetry_tesla_protocol_command_car_server.Action.encode(action).finish()));
+		return this.readData(reply);
 	}
-	vehicleAction(action) {
-		return this.sendInfotainment(_teslemetry_tesla_protocol_command_car_server.Action.create({ vehicleAction: action }));
+	vehicleAction(action, options) {
+		return this.sendInfotainment(_teslemetry_tesla_protocol_command_car_server.Action.create({ vehicleAction: action }), options);
+	}
+	moveTonneau(tonneau) {
+		return this.sendVehicleSecurity(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.create({ closureMoveRequest: _teslemetry_tesla_protocol_command_vcsec.ClosureMoveRequest.create({ tonneau }) }));
 	}
 	resolveSeat(seat_position) {
 		return typeof seat_position === "string" ? require_const.Seats[seat_position] : seat_position;
 	}
+	/** Pings the vehicle. On success, `reason` is the vehicle's timestamp in ISO 8601. */
+	async ping() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ ping: _teslemetry_tesla_protocol_command_car_server.Ping.create({ pingId: 0 }) }), { mutating: false });
+	}
+	/**
+	* Add or modify a charging schedule. At least one of `start_time` or `end_time` is required.
+	* @param days_of_week Comma-joined day names (e.g. `"Mon,Wed"`, `"All"`, `"Weekdays"`) or a day bitmask
+	* @param enabled `true` or `false`
+	* @param lat Latitude of the schedule's location
+	* @param lon Longitude of the schedule's location
+	* @param start_time Minutes after midnight to start charging
+	* @param end_time Minutes after midnight to stop charging
+	* @param one_time Run the schedule only once
+	* @param id Schedule ID to modify an existing schedule
+	* @param name Schedule name
+	*/
+	async add_charge_schedule(days_of_week, enabled, lat, lon, start_time, end_time, one_time, id, name) {
+		if (start_time == null && end_time == null) throw new Error("Either start_time or end_time or both must be provided");
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ addChargeScheduleAction: _teslemetry_tesla_protocol_command_common.ChargeSchedule.create({
+			daysOfWeek: days_of_week_mask(days_of_week),
+			enabled,
+			startEnabled: start_time != null,
+			endEnabled: end_time != null,
+			latitude: lat,
+			longitude: lon,
+			startTime: start_time,
+			endTime: end_time,
+			oneTime: one_time,
+			id,
+			name
+		}) }));
+	}
+	/**
+	* Registers a managed charging site, for a utility managed-charging program, on this vehicle.
+	* @param public_key The raw EC point string the vehicle expects, not the DER a gateway's `get_signed_commands_public_key` returns
+	* @param din The gateway's DIN, which the vehicle matches to the site controller
+	* @param lat Latitude
+	* @param lon Longitude
+	*/
+	async add_managed_charging_site(public_key, din, lat, lon) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ addManagedChargingSiteRequest: _teslemetry_tesla_protocol_command_car_server.AddManagedChargingSiteRequest.create({ site: _teslemetry_tesla_protocol_command_car_server.ManagedChargingSite.create({
+			publicKey: public_key,
+			managerType: _teslemetry_tesla_protocol_command_car_server.ManagerType.create({ siteController: _teslemetry_tesla_protocol_command_car_server.SiteController.create({ din }) }),
+			latLon: _teslemetry_tesla_protocol_command_common.LatLong.create({
+				latitude: lat,
+				longitude: lon
+			})
+		}) }) }));
+	}
+	/**
+	* Add or modify a preconditioning schedule.
+	* @param days_of_week Comma-joined day names (e.g. `"Mon,Wed"`, `"All"`, `"Weekdays"`) or a day bitmask
+	* @param enabled `true` or `false`
+	* @param lat Latitude of the schedule's location
+	* @param lon Longitude of the schedule's location
+	* @param precondition_time Minutes after midnight to be preconditioned by
+	* @param id Schedule ID to modify an existing schedule
+	* @param one_time Run the schedule only once
+	* @param name Schedule name
+	*/
+	async add_precondition_schedule(days_of_week, enabled, lat, lon, precondition_time, id, one_time, name) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ addPreconditionScheduleAction: _teslemetry_tesla_protocol_command_common.PreconditionSchedule.create({
+			daysOfWeek: days_of_week_mask(days_of_week),
+			enabled,
+			preconditionTime: precondition_time,
+			latitude: lat,
+			longitude: lon,
+			oneTime: one_time,
+			id,
+			name
+		}) }));
+	}
 	/**
 	* Controls the front (which_trunk: "front") or rear (which_trunk: "rear") trunk.
 	* @param which_trunk "front" or "rear"
 	*/
-	async actuate_truck(which_trunk) {
+	async actuate_trunk(which_trunk) {
 		const field = TrunkFields[which_trunk];
 		if (!field) throw new Error(`Invalid trunk: ${which_trunk}`);
 		const closureMoveRequest = {};
@@ -325,6 +770,7 @@ var Commands = class extends require_vehiclespecific.default {
 	* @param volume A floating point number from 0.0 to 11.0.
 	*/
 	async adjust_volume(volume) {
+		if (volume < 0 || volume > 11) throw new Error("Volume must a number from 0.0 to 11.0");
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ mediaUpdateVolume: _teslemetry_tesla_protocol_command_car_server.MediaUpdateVolume.create({ volumeAbsoluteFloat: volume }) }));
 	}
 	/** Starts climate preconditioning. */
@@ -335,10 +781,44 @@ var Commands = class extends require_vehiclespecific.default {
 	async auto_conditioning_stop() {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacAutoAction: _teslemetry_tesla_protocol_command_car_server.HvacAutoAction.create({ powerOn: false }) }));
 	}
+	/** Auto secures the vehicle: locks it and closes what it can. */
+	async auto_secure_vehicle() {
+		return this.sendVehicleSecurity(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.create({ RKEAction: _teslemetry_tesla_protocol_command_vcsec.RKEActionE.RKE_ACTION_AUTO_SECURE_VEHICLE }));
+	}
+	/**
+	* Removes charging schedules by location type.
+	* @param home Remove schedules at home
+	* @param work Remove schedules at work
+	* @param other Remove schedules at other locations
+	*/
+	async batch_remove_charge_schedules(home, work, other) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ batchRemoveChargeSchedulesAction: _teslemetry_tesla_protocol_command_car_server.BatchRemoveChargeSchedulesAction.create({
+			home,
+			work,
+			other
+		}) }));
+	}
+	/**
+	* Removes preconditioning schedules by location type.
+	* @param home Remove schedules at home
+	* @param work Remove schedules at work
+	* @param other Remove schedules at other locations
+	*/
+	async batch_remove_precondition_schedules(home, work, other) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ batchRemovePreconditionSchedulesAction: _teslemetry_tesla_protocol_command_car_server.BatchRemovePreconditionSchedulesAction.create({
+			home,
+			work,
+			other
+		}) }));
+	}
 	/** Cancels the countdown to install the vehicle software update. */
 	async cancel_software_update() {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlCancelSoftwareUpdateAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlCancelSoftwareUpdateAction.create({}) }));
 	}
+	/** Cancels a State of Health test. */
+	async cancel_soh_test() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ cancelSohTestAction: _teslemetry_tesla_protocol_command_car_server.CancelSohTestAction.create({}) }));
+	}
 	/** Charges in max range mode -- we recommend limiting the use of this mode to long trips. */
 	async charge_max_range() {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ chargingStartStopAction: _teslemetry_tesla_protocol_command_car_server.ChargingStartStopAction.create({ startMaxRange: VOID }) }));
@@ -365,9 +845,18 @@ var Commands = class extends require_vehiclespecific.default {
 	}
 	/**
 	* Deactivates PIN to Drive and resets the associated PIN for vehicles running firmware versions 2023.44+. This command is only accessible to fleet managers or owners.
+	* @param _pin Accepted for parity with the REST command; the signed action carries no PIN.
 	*/
-	async clear_pin_to_drive_admin() {
-		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlResetPinToDriveAdminAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlResetPinToDriveAdminAction.create({}) }));
+	async clear_pin_to_drive_admin(_pin) {
+		return this.reset_pin_to_drive_admin();
+	}
+	/** Closes the Cybertruck tonneau cover. */
+	async close_tonneau() {
+		return this.moveTonneau(_teslemetry_tesla_protocol_command_vcsec.ClosureMoveTypeE.CLOSURE_MOVE_TYPE_CLOSE);
+	}
+	/** Saves a dashcam clip. */
+	async dashcam_save_clip() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ dashcamSaveClipAction: _teslemetry_tesla_protocol_command_car_server.DashcamSaveClipAction.create({}) }));
 	}
 	/** Locks the vehicle. */
 	async door_lock() {
@@ -385,6 +874,22 @@ var Commands = class extends require_vehiclespecific.default {
 	async flash_lights() {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlFlashLightsAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlFlashLightsAction.create({}) }));
 	}
+	/** Gets the charge on solar settings, under `response.getChargeOnSolarFeatureResponse`. */
+	async get_charge_on_solar() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ getChargeOnSolarFeatureRequest: _teslemetry_tesla_protocol_command_car_server.GetChargeOnSolarFeatureRequest.create({}) }), { mutating: false });
+	}
+	/** Gets the registered managed charging sites, under `response.getManagedChargingSitesResponse`. */
+	async get_managed_charging_sites() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ getManagedChargingSitesRequest: _teslemetry_tesla_protocol_command_car_server.GetManagedChargingSitesRequest.create({}) }), { mutating: false });
+	}
+	/** Gets vehicle in-car messages. The reply carries the vehicle's response under `getMessagesResponse`, if it sends one. */
+	async get_messages() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ getMessagesAction: _teslemetry_tesla_protocol_command_car_server.GetMessagesAction.create({}) }), { mutating: false });
+	}
+	/** Gets the current time-of-use rate tariff schedule, under `response.getRateTariffResponse`. */
+	async get_rate_tariff() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ getRateTariffRequest: _teslemetry_tesla_protocol_command_car_server.GetRateTariffRequest.create({}) }), { mutating: false });
+	}
 	/**
 	* Restricts certain vehicle UI functionality from guest users
 	* @param enable `true` or `false`
@@ -420,6 +925,25 @@ var Commands = class extends require_vehiclespecific.default {
 	async media_volume_down() {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ mediaUpdateVolume: _teslemetry_tesla_protocol_command_car_server.MediaUpdateVolume.create({ volumeDelta: -1 }) }));
 	}
+	/** Turns the volume up by one. */
+	async media_volume_up() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ mediaUpdateVolume: _teslemetry_tesla_protocol_command_car_server.MediaUpdateVolume.create({ volumeDelta: 1 }) }));
+	}
+	/**
+	* Start navigation to coordinates with a named destination.
+	* @param lat Latitude
+	* @param lon Longitude
+	* @param destination Destination name
+	* @param order Trip order: `0` replaces the current trip (default), `1` prepends it as the next stop, `2` appends it as the last stop
+	*/
+	async navigation_gps_destination_request(lat, lon, destination, order = 0) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ navigationGpsDestinationRequest: _teslemetry_tesla_protocol_command_car_server.NavigationGpsDestinationRequest.create({
+			lat,
+			lon,
+			destination,
+			order
+		}) }));
+	}
 	/**
 	* Start navigation to given coordinates.
 	* @param lat Latitude
@@ -436,13 +960,13 @@ var Commands = class extends require_vehiclespecific.default {
 	/**
 	* Sends a location to the in-vehicle navigation system.
 	*
-	* `locale` and `type` are REST-only fields with no equivalent in the
-	* signed-command protocol (which only carries a destination string and a
-	* multi-stop order), so they are accepted for cross-transport signature
-	* parity but not sent.
+	* `type`, `locale` and `timestamp_ms` are REST-only fields with no equivalent
+	* in the signed-command protocol, which only carries a destination string
+	* and a multi-stop order. They keep REST's positions, so the router's types
+	* agree, and are not sent.
 	* @param value Destination text
 	*/
-	async navigation_request(value, _locale, _type) {
+	async navigation_request(value, _type, _locale, _timestamp_ms) {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ navigationRequest: _teslemetry_tesla_protocol_command_car_server.NavigationRequest.create({ destination: value }) }));
 	}
 	/**
@@ -456,6 +980,35 @@ var Commands = class extends require_vehiclespecific.default {
 			remoteNavTripOrder: order ?? 0
 		}) }));
 	}
+	/** Triggers vehicle route navigation. */
+	async navigation_route() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ navigationRouteAction: _teslemetry_tesla_protocol_command_car_server.NavigationRouteAction.create({}) }));
+	}
+	/**
+	* Sends a list of waypoints to the vehicle's navigation system.
+	* @param waypoints Comma-separated Google Maps place IDs, e.g. `"refId:ChIJ...,refId:ChIJ..."`
+	*/
+	async navigation_waypoints_request(waypoints) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ navigationWaypointsRequest: _teslemetry_tesla_protocol_command_car_server.NavigationWaypointsRequest.create({ waypoints }) }));
+	}
+	/** Opens the Cybertruck tonneau cover. */
+	async open_tonneau() {
+		return this.moveTonneau(_teslemetry_tesla_protocol_command_vcsec.ClosureMoveTypeE.CLOSURE_MOVE_TYPE_OPEN);
+	}
+	/**
+	* Returns the charging sites near the current location of the vehicle.
+	* The sites are under `response.getNearbyChargingSites`.
+	* @param count Number of sites to return
+	* @param radius Search radius
+	* @param detail Whether to include site metadata
+	*/
+	async nearby_charging_sites(count, radius, detail) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ getNearbyChargingSites: _teslemetry_tesla_protocol_command_car_server.GetNearbyChargingSites.create({
+			count,
+			radius,
+			includeMetaData: detail
+		}) }), { mutating: false });
+	}
 	/**
 	* Sets automatic seat heating and cooling. Only the front seats support this action.
 	* @param auto_seat_position `AutoSeat` position (1-indexed: front left is 1, front right is 2)
@@ -477,6 +1030,27 @@ var Commands = class extends require_vehiclespecific.default {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ autoStwHeatAction: _teslemetry_tesla_protocol_command_car_server.AutoStwHeatAction.create({ on }) }));
 	}
 	/**
+	* Removes a charging schedule.
+	* @param id Schedule ID
+	*/
+	async remove_charge_schedule(id) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ removeChargeScheduleAction: _teslemetry_tesla_protocol_command_car_server.RemoveChargeScheduleAction.create({ id }) }));
+	}
+	/**
+	* Removes a registered managed charging site.
+	* @param public_key The public key it was registered with
+	*/
+	async remove_managed_charging_site(public_key) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ removeManagedChargingSiteRequest: _teslemetry_tesla_protocol_command_car_server.RemoveManagedChargingSiteRequest.create({ publicKey: public_key }) }));
+	}
+	/**
+	* Removes a preconditioning schedule.
+	* @param id Schedule ID
+	*/
+	async remove_precondition_schedule(id) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ removePreconditionScheduleAction: _teslemetry_tesla_protocol_command_car_server.RemovePreconditionScheduleAction.create({ id }) }));
+	}
+	/**
 	* Plays a sound through the vehicle external speaker.
 	* @param sound Fart is `0`, Locate ping is `2000`
 	*/
@@ -485,11 +1059,11 @@ var Commands = class extends require_vehiclespecific.default {
 	}
 	/**
 	* Sets seat cooling. Only the front seats support this action.
-	* @param seat_position Seat position
+	* @param seat_position `AutoSeat` position (1-indexed: front left is 1, front right is 2), unlike seat heating
 	* @param seat_cooler_level Cooling level
 	*/
 	async remote_seat_cooler_request(seat_position, seat_cooler_level) {
-		const position = SeatCoolerPositions[this.resolveSeat(seat_position)];
+		const position = SeatCoolerPositions[typeof seat_position === "string" ? require_const.AutoSeat[seat_position] : seat_position];
 		if (position === void 0) throw new Error(`Invalid seat position for seat cooling: ${seat_position}`);
 		const level = SeatCoolerLevels[seat_cooler_level];
 		if (level === void 0) throw new Error(`Invalid seat cooler level: ${seat_cooler_level}`);
@@ -519,11 +1093,11 @@ var Commands = class extends require_vehiclespecific.default {
 	}
 	/**
 	* Sets steering wheel heat level.
-	* @param level Heating level (0=Off, 1=Low, 2=High)
+	* @param level `Level` OFF, LOW or HIGH (0, 1, 3). There is no medium level.
 	*/
 	async remote_steering_wheel_heat_level_request(level) {
 		const stwLevel = StwHeatLevels[level];
-		if (stwLevel === void 0) throw new Error(`Invalid steering wheel heat level: ${level}`);
+		if (stwLevel === void 0) throw new Error(`Invalid steering wheel heat level ${level}; expected 0, 1 or 3`);
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ stwHeatLevelAction: _teslemetry_tesla_protocol_command_car_server.StwHeatLevelAction.create({ stwHeatLevel: stwLevel }) }));
 	}
 	/**
@@ -533,6 +1107,14 @@ var Commands = class extends require_vehiclespecific.default {
 	async remote_steering_wheel_heater_request(on) {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacSteeringWheelHeaterAction: _teslemetry_tesla_protocol_command_car_server.HvacSteeringWheelHeaterAction.create({ powerOn: on }) }));
 	}
+	/**
+	* Resets PIN to Drive for fleet managers and owners. Requires firmware 2023.44+.
+	* The vehicle only accepts this with account credentials, which the cloud
+	* transport has and a raw Bluetooth link does not.
+	*/
+	async reset_pin_to_drive_admin() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlResetPinToDriveAdminAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlResetPinToDriveAdminAction.create({}) }));
+	}
 	/** Removes PIN to Drive. Requires the car to be in Pin to Drive mode and not in Valet mode. */
 	async reset_pin_to_drive_pin() {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlResetPinToDriveAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlResetPinToDriveAction.create({}) }));
@@ -608,6 +1190,27 @@ var Commands = class extends require_vehiclespecific.default {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setCopTempAction: _teslemetry_tesla_protocol_command_car_server.SetCopTempAction.create({ copActivationTemp }) }));
 	}
 	/**
+	* Sets the vehicle's general discharge limit. This is not `set_powershare_discharge_limit`, which is a separate message.
+	* @param discharge_limit Discharge limit
+	*/
+	async set_discharge_limit(discharge_limit) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setDischargeLimitAction: _teslemetry_tesla_protocol_command_car_server.SetDischargeLimitAction.create({ dischargeLimit: discharge_limit }) }));
+	}
+	/**
+	* Turns Keep Accessory Power mode on and off, keeping 12V accessory power available while the vehicle is parked.
+	* @param on `true` or `false`
+	*/
+	async set_keep_accessory_power_mode(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setKeepAccessoryPowerModeAction: _teslemetry_tesla_protocol_command_car_server.SetKeepAccessoryPowerModeAction.create({ keepAccessoryPowerMode: on }) }));
+	}
+	/**
+	* Turns Low Power mode on and off, reducing standby power consumption while the vehicle is parked.
+	* @param on `true` or `false`
+	*/
+	async set_low_power_mode(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setLowPowerModeAction: _teslemetry_tesla_protocol_command_car_server.SetLowPowerModeAction.create({ lowPowerMode: on }) }));
+	}
+	/**
 	* Sets a four-digit passcode for PIN to Drive.
 	* @param on `true` or `false`
 	* @param password Four-digit passcode
@@ -630,6 +1233,26 @@ var Commands = class extends require_vehiclespecific.default {
 		}) }));
 	}
 	/**
+	* Sets a time-of-use rate tariff schedule. The schedule nests up to five
+	* named seasons of four period types each, so build `seasons` and `tariff`
+	* with the `tesla-protocol` message types.
+	* @param seasons The tariff's seasons
+	* @param tariff The tariff
+	*/
+	async set_rate_tariff(seasons, tariff) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setRateTariffRequest: _teslemetry_tesla_protocol_command_car_server.SetRateTariffRequest.create({
+			seasons,
+			tariff
+		}) }));
+	}
+	/**
+	* Sets HVAC recirculation mode on and off.
+	* @param on `true` or `false`
+	*/
+	async set_recirculation(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacRecirculationAction: _teslemetry_tesla_protocol_command_car_server.HvacRecirculationAction.create({ on }) }));
+	}
+	/**
 	* Sets a time at which charging should be completed.
 	* @param enable `true` or `false`
 	* @param time Minutes after midnight
@@ -643,20 +1266,25 @@ var Commands = class extends require_vehiclespecific.default {
 	/**
 	* Sets a time at which departure should be completed.
 	*
-	* `preconditioning_enabled` and `off_peak_charging_enabled` are accepted
-	* for cross-transport signature parity but have no field in the signed
-	* command protobuf, so they are not sent.
+	* The protocol has no enable flags: a present recurrence block switches its
+	* feature on. So preconditioning and off-peak charging are sent only when
+	* their `*_enabled` or `*_weekdays_only` argument is true, and an absent
+	* block is what turns the feature off.
 	* @param enable `true` or `false`
-	* @param preconditioning_enabled not representable in a signed command
+	* @param preconditioning_enabled `true` or `false`
 	* @param preconditioning_weekdays_only `true` or `false`
 	* @param departure_time Minutes after midnight
-	* @param off_peak_charging_enabled not representable in a signed command
+	* @param off_peak_charging_enabled `true` or `false`
 	* @param off_peak_charging_weekdays_only `true` or `false`
 	* @param end_off_peak_time Minutes after midnight
 	*/
-	async set_scheduled_departure(enable = true, _preconditioning_enabled = false, preconditioning_weekdays_only = false, departure_time = 0, _off_peak_charging_enabled = false, off_peak_charging_weekdays_only = false, end_off_peak_time = 0) {
-		const preconditioningTimes = preconditioning_weekdays_only ? _teslemetry_tesla_protocol_command_common.PreconditioningTimes.create({ weekdays: VOID }) : _teslemetry_tesla_protocol_command_common.PreconditioningTimes.create({ allWeek: VOID });
-		const offPeakChargingTimes = off_peak_charging_weekdays_only ? _teslemetry_tesla_protocol_command_common.OffPeakChargingTimes.create({ weekdays: VOID }) : _teslemetry_tesla_protocol_command_common.OffPeakChargingTimes.create({ allWeek: VOID });
+	async set_scheduled_departure(enable = true, preconditioning_enabled = false, preconditioning_weekdays_only = false, departure_time = 0, off_peak_charging_enabled = false, off_peak_charging_weekdays_only = false, end_off_peak_time = 0) {
+		let preconditioningTimes;
+		if (preconditioning_weekdays_only) preconditioningTimes = _teslemetry_tesla_protocol_command_common.PreconditioningTimes.create({ weekdays: VOID });
+		else if (preconditioning_enabled) preconditioningTimes = _teslemetry_tesla_protocol_command_common.PreconditioningTimes.create({ allWeek: VOID });
+		let offPeakChargingTimes;
+		if (off_peak_charging_weekdays_only) offPeakChargingTimes = _teslemetry_tesla_protocol_command_common.OffPeakChargingTimes.create({ weekdays: VOID });
+		else if (off_peak_charging_enabled) offPeakChargingTimes = _teslemetry_tesla_protocol_command_common.OffPeakChargingTimes.create({ allWeek: VOID });
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ scheduledDepartureAction: _teslemetry_tesla_protocol_command_car_server.ScheduledDepartureAction.create({
 			enabled: enable,
 			departureTime: departure_time,
@@ -673,6 +1301,13 @@ var Commands = class extends require_vehiclespecific.default {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlSetSentryModeAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlSetSentryModeAction.create({ on }) }));
 	}
 	/**
+	* Sets the vehicle suspension level.
+	* @param level `1` entry, `2` low, `3` medium, `4` high, `5` very high, `6` extract
+	*/
+	async set_suspension_level(level) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setSuspensionLevelAction: _teslemetry_tesla_protocol_command_car_server.SetSuspensionLevelAction.create({ suspensionLevel: level }) }));
+	}
+	/**
 	* Sets the driver and/or passenger-side cabin temperature (and other zones if sync is enabled).
 	* @param driver_temp Driver temperature
 	* @param passenger_temp Passenger temperature
@@ -684,6 +1319,13 @@ var Commands = class extends require_vehiclespecific.default {
 		}) }));
 	}
 	/**
+	* Enables or disables tent mode.
+	* @param on `true` or `false`
+	*/
+	async set_tent_mode(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setTentModeRequestAction: _teslemetry_tesla_protocol_command_car_server.SetTentModeRequestAction.create({ on }) }));
+	}
+	/**
 	* Turns on Valet Mode and sets a four-digit passcode.
 	* @param on `true` or `false`
 	* @param password Four-digit passcode
@@ -691,7 +1333,7 @@ var Commands = class extends require_vehiclespecific.default {
 	async set_valet_mode(on, password) {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlSetValetModeAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlSetValetModeAction.create({
 			on,
-			password: String(password)
+			password: password == null ? void 0 : String(password)
 		}) }));
 	}
 	/**
@@ -740,15 +1382,39 @@ var Commands = class extends require_vehiclespecific.default {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ drivingSetSpeedLimitAction: _teslemetry_tesla_protocol_command_car_server.DrivingSetSpeedLimitAction.create({ limitMph: limit_mph }) }));
 	}
 	/**
+	* Starts a light show.
+	* @param show_index Index of the show
+	* @param start_time Start time
+	* @param volume Volume
+	* @param dance_moves Whether the vehicle moves during the show
+	*/
+	async start_light_show(show_index = 0, start_time = 0, volume = 0, dance_moves = false) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ startLightShowAction: _teslemetry_tesla_protocol_command_car_server.StartLightShowAction.create({
+			showIndex: show_index,
+			startTime: start_time,
+			volume,
+			danceMoves: dance_moves
+		}) }));
+	}
+	/** Stops the current light show. */
+	async stop_light_show() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ stopLightShowAction: _teslemetry_tesla_protocol_command_car_server.StopLightShowAction.create({}) }));
+	}
+	/** Stops the Cybertruck tonneau cover. */
+	async stop_tonneau() {
+		return this.moveTonneau(_teslemetry_tesla_protocol_command_vcsec.ClosureMoveTypeE.CLOSURE_MOVE_TYPE_STOP);
+	}
+	/**
 	* Controls the panoramic sunroof on the Model S.
 	*
 	* "stop" has no corresponding field in the signed-command protobuf (only
 	* vent/close/open), so it is rejected rather than guessed at.
-	* @param state "close" or "vent"
+	* @param state "open", "close" or "vent"
 	*/
 	async sun_roof_control(state) {
 		let action;
 		if (state === "vent") action = _teslemetry_tesla_protocol_command_car_server.VehicleControlSunroofOpenCloseAction.create({ vent: VOID });
+		else if (state === "open") action = _teslemetry_tesla_protocol_command_car_server.VehicleControlSunroofOpenCloseAction.create({ open: VOID });
 		else if (state === "close") action = _teslemetry_tesla_protocol_command_car_server.VehicleControlSunroofOpenCloseAction.create({ close: VOID });
 		else throw new Error("sun_roof_control: \"stop\" is not representable in a signed command.");
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlSunroofOpenCloseAction: action }));
@@ -765,20 +1431,33 @@ var Commands = class extends require_vehiclespecific.default {
 	}
 	/**
 	* Turns on HomeLink (used to open and close garage doors).
-	* @param lat Latitude
-	* @param lon Longitude
 	* @param token
+	* @param lat Latitude. `0` is a coordinate; the location is sent when both are given.
+	* @param lon Longitude
 	*/
-	async trigger_homelink(lat, lon, token = "") {
+	async trigger_homelink(token, lat, lon) {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlTriggerHomelinkAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlTriggerHomelinkAction.create({
-			location: _teslemetry_tesla_protocol_command_common.LatLong.create({
+			location: lat != null && lon != null ? _teslemetry_tesla_protocol_command_common.LatLong.create({
 				latitude: lat,
 				longitude: lon
-			}),
+			}) : void 0,
 			token
 		}) }));
 	}
 	/**
+	* Updates the charge on solar settings.
+	* @param enabled `true` or `false`
+	* @param lower_charge_limit Lower charge limit
+	* @param upper_charge_limit Upper charge limit
+	*/
+	async update_charge_on_solar(enabled, lower_charge_limit, upper_charge_limit) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ updateChargeOnSolarFeatureRequest: _teslemetry_tesla_protocol_command_car_server.UpdateChargeOnSolarFeatureRequest.create({ chargeOnSolar: _teslemetry_tesla_protocol_command_car_server.ChargeOnSolarFeature.create({
+			enabled,
+			lowerChargeLimit: lower_charge_limit,
+			upperChargeLimit: upper_charge_limit
+		}) }) }));
+	}
+	/**
 	* Sends upcoming calendar entries to the vehicle. Overrides the inherited
 	* plaintext command so it is signed and dispatched over the vehicle-command
 	* protocol rather than silently falling through to the unsigned REST
@@ -789,14 +1468,330 @@ var Commands = class extends require_vehiclespecific.default {
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ uiSetUpcomingCalendarEntries: _teslemetry_tesla_protocol_command_car_server.UiSetUpcomingCalendarEntries.create({ calendarData: calendar_data }) }));
 	}
 	/**
+	* Asks the vehicle to open a video stream.
+	* @param url Video URL
+	*/
+	async video_request(url) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ videoRequestAction: _teslemetry_tesla_protocol_command_car_server.VideoRequestAction.create({ url }) }));
+	}
+	/**
 	* Control the windows of a parked vehicle. Supported commands: vent and close.
 	* @param command "vent" or "close"
 	* @param lat Latitude
 	* @param lon Longitude
 	*/
 	async window_control(command, _lat, _lon) {
-		const action = command === "vent" ? _teslemetry_tesla_protocol_command_car_server.VehicleControlWindowAction.create({ vent: VOID }) : _teslemetry_tesla_protocol_command_car_server.VehicleControlWindowAction.create({ close: VOID });
+		let action;
+		if (command === "vent") action = _teslemetry_tesla_protocol_command_car_server.VehicleControlWindowAction.create({ vent: VOID });
+		else if (command === "close") action = _teslemetry_tesla_protocol_command_car_server.VehicleControlWindowAction.create({ close: VOID });
+		else throw new Error(`Invalid window command: ${command}`);
 		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlWindowAction: action }));
 	}
+	/**
+	* Requests a PII key, for privacy and telemetry pseudonymization.
+	* @param subscriber_public_key Subscriber public key
+	* @param pii_key_expiration Expiry as a Unix timestamp in seconds
+	*/
+	async pii_key_request(subscriber_public_key, pii_key_expiration) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ piiKeyRequest: _teslemetry_tesla_protocol_command_car_server.PiiKeyRequest.create({
+			subscriberPublicKey: subscriber_public_key,
+			piiKeyExpiration: /* @__PURE__ */ new Date(pii_key_expiration * 1e3)
+		}) }));
+	}
+	/**
+	* Syncs the vehicle's privacy and telemetry pseudonym with a previously known hashed value.
+	* @param last_known_pseudonym_hashed The hashed pseudonym
+	*/
+	async pseudonym_sync_request(last_known_pseudonym_hashed) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ pseudonymSyncRequest: _teslemetry_tesla_protocol_command_car_server.PseudonymSyncRequest.create({ lastKnownPseudonymHashed: last_known_pseudonym_hashed }) }));
+	}
+	/**
+	* Passes a completed "Sign in with Tesla" OAuth response to the vehicle
+	* screen. The caller must already hold that response from its own auth flow.
+	* @param client_id OAuth client ID
+	* @param scope OAuth scope
+	* @param access_token Access token
+	* @param refresh_token Refresh token
+	* @param expiry_timestamp Token expiry
+	* @param error OAuth error, if any
+	* @param scoped_token Scoped token
+	*/
+	async tesla_auth_response(client_id, scope, access_token, refresh_token, expiry_timestamp, error = "", scoped_token = "") {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ teslaAuthResponseAction: _teslemetry_tesla_protocol_command_car_server.TeslaAuthResponseAction.create({
+			clientId: client_id,
+			scope,
+			accessToken: access_token,
+			refreshToken: refresh_token,
+			expiryTimestamp: expiry_timestamp,
+			error,
+			scopedToken: scoped_token
+		}) }));
+	}
+	/**
+	* Links a local Tesla profile to a cloud vault profile.
+	* @param cloud_vault_uuid Cloud vault UUID
+	* @param local_profile_uuid Local profile UUID
+	* @param delete_local_profile_after_setup Whether to delete the local profile afterwards
+	*/
+	async setup_cloud_profile_with_local_profile_uuid(cloud_vault_uuid, local_profile_uuid, delete_local_profile_after_setup = false) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setupCloudProfileWithLocalProfileUuidAction: _teslemetry_tesla_protocol_command_car_server.SetupCloudProfileWithLocalProfileUuidAction.create({
+			cloudVaultUuid: cloud_vault_uuid,
+			localProfileUuid: local_profile_uuid,
+			deleteLocalProfileAfterSetup: delete_local_profile_after_setup
+		}) }));
+	}
+	/**
+	* Gets the local Tesla profiles of a cloud vault, under `response.getLocalProfilesResponse`.
+	* @param vault_uuid Cloud vault UUID
+	*/
+	async get_local_profiles_for_vault_uuid(vault_uuid) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ getLocalProfilesForVaultUuidAction: _teslemetry_tesla_protocol_command_car_server.GetLocalProfilesForVaultUuidAction.create({ vaultUuid: vault_uuid }) }), { mutating: false });
+	}
+	/**
+	* Requests Bluetooth Classic, not BLE, pairing with a phone for calls and audio.
+	* @param name Device name
+	* @param mac_address Device MAC address
+	*/
+	async bluetooth_classic_pairing_request(name, mac_address) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ bluetoothClassicPairingRequest: _teslemetry_tesla_protocol_command_car_server.BluetoothClassicPairingRequest.create({
+			utf8Name: name,
+			macAddress: mac_address
+		}) }));
+	}
+	/**
+	* Runs a diagnostic bandwidth test, with its result under `response.bandwidthTestResponse`.
+	* @param requested_size Size in bytes
+	*/
+	async bandwidth_test(requested_size) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ bandwidthTest: _teslemetry_tesla_protocol_command_car_server.BandwidthTest.create({ requestedSize: requested_size }) }));
+	}
+	/** Gets information about keys paired with the vehicle, under `response.keysInfoResponse`. */
+	async fetch_keys_info() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ fetchKeysInfoAction: _teslemetry_tesla_protocol_command_car_server.FetchKeysInfoAction.create({}) }), { mutating: false });
+	}
+	/** Formats the USB drive connected to the vehicle, erasing all files on it. Irreversible. */
+	async format_usb() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ formatUsbAction: _teslemetry_tesla_protocol_command_car_server.FormatUSBAction.create({ formatUsb: true }) }));
+	}
+	/** Deletes all dashcam clips stored on the vehicle. Irreversible. */
+	async delete_dashcam_clips() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ deleteDashcamClipsAction: _teslemetry_tesla_protocol_command_car_server.DeleteDashcamClipsAction.create({ deleteClips: true }) }));
+	}
+	/**
+	* Activates or deactivates parental controls.
+	* @param activate `true` or `false`
+	* @param pin Four-digit PIN
+	*/
+	async parental_controls(activate, pin) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ parentalControlsAction: _teslemetry_tesla_protocol_command_car_server.ParentalControlsAction.create({
+			activate,
+			pin: String(pin)
+		}) }));
+	}
+	/**
+	* Clears the parental controls PIN.
+	* @param pin Four-digit PIN
+	*/
+	async parental_controls_clear_pin(pin) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ parentalControlsClearPinAction: _teslemetry_tesla_protocol_command_car_server.ParentalControlsClearPinAction.create({ pin: String(pin) }) }));
+	}
+	/** Clears the parental controls PIN, for fleet managers and owners. */
+	async parental_controls_clear_pin_admin() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ parentalControlsClearPinAdminAction: _teslemetry_tesla_protocol_command_car_server.ParentalControlsClearPinAdminAction.create({}) }));
+	}
+	/**
+	* Enables or disables a parental controls setting.
+	* @param setting `0` speed limit, `1` acceleration, `2` safety features, `3` curfew, `4` browser blocked, `5` theater blocked, `6` arcade blocked
+	* @param enable `true` or `false`
+	*/
+	async parental_controls_enable_setting(setting, enable) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ parentalControlsEnableSettingsAction: _teslemetry_tesla_protocol_command_car_server.ParentalControlsEnableSettingsAction.create({
+			setting,
+			enable
+		}) }));
+	}
+	/**
+	* Sets the parental controls speed limit.
+	* @param limit_mph Maximum speed in MPH
+	*/
+	async parental_controls_set_speed_limit(limit_mph) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ parentalControlsSetSpeedLimitAction: _teslemetry_tesla_protocol_command_car_server.ParentalControlsSetSpeedLimitAction.create({ limitMph: limit_mph }) }));
+	}
+	/**
+	* Sets the displayed temperature unit.
+	* @param unit `TemperatureUnit`
+	*/
+	async set_temperature_unit(unit) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setTemperatureUnitAction: _teslemetry_tesla_protocol_command_car_server.SetTemperatureUnitAction.create({ unit }) }));
+	}
+	/**
+	* Sets the displayed distance unit.
+	* @param unit `DistanceUnit`
+	*/
+	async set_distance_unit(unit) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setDistanceUnitAction: _teslemetry_tesla_protocol_command_car_server.SetDistanceUnitAction.create({ unit }) }));
+	}
+	/**
+	* Sets the displayed clock format.
+	* @param format `TimeDisplayFormat`
+	*/
+	async set_time_display_format(format) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setTimeDisplayFormatAction: _teslemetry_tesla_protocol_command_car_server.SetTimeDisplayFormatAction.create({ format }) }));
+	}
+	/**
+	* Sets the displayed tire pressure unit.
+	* @param unit `TirePressureUnit`
+	*/
+	async set_tire_pressure_unit(unit) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setTirePressureUnitAction: _teslemetry_tesla_protocol_command_car_server.SetTirePressureUnitAction.create({ unit }) }));
+	}
+	/**
+	* Sets the displayed energy or range unit.
+	* @param format `EnergyDisplayFormat`
+	*/
+	async set_energy_display_format(format) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setEnergyDisplayFormatAction: _teslemetry_tesla_protocol_command_car_server.SetEnergyDisplayFormatAction.create({ format }) }));
+	}
+	/**
+	* Sets paired-phone display preferences.
+	* @param font_size `PhoneFontSize`
+	* @param options.distance_unit `DistanceUnit`
+	* @param options.temperature_unit `TemperatureUnit`
+	*/
+	async set_phone_setting_preferences(font_size = require_const.PhoneFontSize.STANDARD, { distance_unit, temperature_unit } = {}) {
+		const unitPreferences = distance_unit != null || temperature_unit != null ? _teslemetry_tesla_protocol_command_car_server.PhoneUnitPreferences.create({
+			distanceUnit: distance_unit,
+			temperatureUnit: temperature_unit
+		}) : void 0;
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setPhoneSettingPreferencesAction: _teslemetry_tesla_protocol_command_car_server.SetPhoneSettingPreferencesAction.create({
+			fontSize: font_size,
+			unitPreferences
+		}) }));
+	}
+	/**
+	* Enables or disables the Powershare feature.
+	* @param on `true` or `false`
+	*/
+	async set_powershare_feature(on) {
+		const powershareFeatureRequest = on ? _teslemetry_tesla_protocol_command_car_server.SetPowershareFeatureAction_PowershareFeatureRequest.POWERSHARE_FEATURE_REQUEST_ON : _teslemetry_tesla_protocol_command_car_server.SetPowershareFeatureAction_PowershareFeatureRequest.POWERSHARE_FEATURE_REQUEST_OFF;
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setPowershareFeatureAction: _teslemetry_tesla_protocol_command_car_server.SetPowershareFeatureAction.create({ powershareFeatureRequest }) }));
+	}
+	/**
+	* Enables or disables powershare.
+	* @param on `true` or `false`
+	*/
+	async set_powershare_request(on) {
+		const powershareRequest = on ? _teslemetry_tesla_protocol_command_car_server.SetPowershareRequestAction_PowershareRequest.POWERSHARE_REQUEST_ON : _teslemetry_tesla_protocol_command_car_server.SetPowershareRequestAction_PowershareRequest.POWERSHARE_REQUEST_OFF;
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setPowershareRequestAction: _teslemetry_tesla_protocol_command_car_server.SetPowershareRequestAction.create({ powershareRequest }) }));
+	}
+	/**
+	* Sets the Powershare discharge limit. This is not `set_discharge_limit`, which is a separate message.
+	* @param percent Discharge limit percentage
+	*/
+	async set_powershare_discharge_limit(percent) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setPowershareDischargeLimitAction: _teslemetry_tesla_protocol_command_car_server.SetPowershareDischargeLimitAction.create({ powershareDischargeLimit: percent }) }));
+	}
+	/**
+	* Sets the outlets on or off.
+	* @param request `0` off, `1` cabin and bed, `2` cabin
+	*/
+	async set_outlets(request) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setOutletsOnOffAction: _teslemetry_tesla_protocol_command_car_server.SetOutletsOnOffAction.create({ outletRequest: request }) }));
+	}
+	/**
+	* Sets the outlet timer.
+	* @param num_minutes Minutes
+	*/
+	async set_outlet_timer(num_minutes) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setOutletTimerAction: _teslemetry_tesla_protocol_command_car_server.SetOutletTimerAction.create({ numMinutes: num_minutes }) }));
+	}
+	/**
+	* Sets the outlet state of charge limit.
+	* @param percent State of charge percentage
+	*/
+	async set_outlet_soc_limit(percent) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setOutletSocLimitAction: _teslemetry_tesla_protocol_command_car_server.SetOutletSocLimitAction.create({ percent }) }));
+	}
+	/**
+	* Sets the power feed on or off.
+	* @param request `0` off, `1` feed 1, `2` feed 2, `3` both
+	*/
+	async set_power_feed(request) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setPowerFeedOnOffAction: _teslemetry_tesla_protocol_command_car_server.SetPowerFeedOnOffAction.create({ powerFeedRequest: request }) }));
+	}
+	/**
+	* Sets the power feed timer.
+	* @param num_minutes Minutes
+	*/
+	async set_power_feed_timer(num_minutes) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setPowerFeedTimerAction: _teslemetry_tesla_protocol_command_car_server.SetPowerFeedTimerAction.create({ numMinutes: num_minutes }) }));
+	}
+	/**
+	* Sets the power feed state of charge limit.
+	* @param percent State of charge percentage
+	*/
+	async set_power_feed_soc_limit(percent) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setPowerFeedSocLimitAction: _teslemetry_tesla_protocol_command_car_server.SetPowerFeedSocLimitAction.create({ percent }) }));
+	}
+	/**
+	* Sets the lightbar brightness.
+	* @param brightness Brightness
+	*/
+	async set_lightbar_brightness(brightness) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setLightbarBrightnessAction: _teslemetry_tesla_protocol_command_car_server.SetLightbarBrightnessAction.create({ brightnessRequest: brightness }) }));
+	}
+	/**
+	* Turns the lightbar middle light on or off.
+	* @param on `true` or `false`
+	*/
+	async set_lightbar_middle(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setLightbarMiddleAction: _teslemetry_tesla_protocol_command_car_server.SetLightbarMiddleAction.create({ middleLightRequest: on }) }));
+	}
+	/**
+	* Turns the ditch lights on or off.
+	* @param on `true` or `false`
+	*/
+	async set_lightbar_ditch(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setLightbarDitchAction: _teslemetry_tesla_protocol_command_car_server.SetLightbarDitchAction.create({ ditchLightsRequest: on }) }));
+	}
+	/**
+	* Sets the front zone light level.
+	* @param level `0` off, `1` low, `2` medium, `3` high
+	*/
+	async set_front_zone_lights(level) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setFrontZoneLightRequestAction: _teslemetry_tesla_protocol_command_car_server.SetZoneLightRequestAction.create({ zoneLightRequest: level }) }));
+	}
+	/**
+	* Sets the rear zone light level.
+	* @param level `0` off, `1` low, `2` medium, `3` high
+	*/
+	async set_rear_zone_lights(level) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setRearZoneLightRequestAction: _teslemetry_tesla_protocol_command_car_server.SetZoneLightRequestAction.create({ zoneLightRequest: level }) }));
+	}
+	/**
+	* Starts or stops the trailer light test.
+	* @param on `true` or `false`
+	*/
+	async set_trailer_light_test(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setTrailerLightTestStartStopAction: _teslemetry_tesla_protocol_command_car_server.SetTrailerLightTestStartStopAction.create({ startStop: on }) }));
+	}
+	/**
+	* Sets the truck bed light's auto state.
+	* @param on `true` or `false`
+	*/
+	async set_truck_bed_light_auto(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setTruckBedLightAutoStateAction: _teslemetry_tesla_protocol_command_car_server.SetTruckBedLightAutoStateAction.create({ powerState: on }) }));
+	}
+	/**
+	* Sets the truck bed light brightness.
+	* @param brightness Brightness
+	*/
+	async set_truck_bed_light_brightness(brightness) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setTruckBedLightBrightnessAction: _teslemetry_tesla_protocol_command_car_server.SetTruckBedLightBrightnessAction.create({ brightness }) }));
+	}
 };
+exports.DAY_OF_WEEK_BITS = DAY_OF_WEEK_BITS;
+exports.days_of_week_mask = days_of_week_mask;
 exports.default = Commands;
+exports.infotainment_command_name = infotainment_command_name;
+exports.vcsec_command_name = vcsec_command_name;