tesla-fleet-api 0.2.2 → 0.4.0

package/dist/commands.cjs

@@ -0,0 +1,802 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_const = require("./const.cjs");
+const require_vehiclespecific = require("./vehiclespecific.cjs");
+const require_session = require("./signing/session.cjs");
+const require_crypto = require("./signing/crypto.cjs");
+const require_exceptions = require("./exceptions.cjs");
+let crypto = require("crypto");
+crypto = require_runtime.__toESM(crypto, 1);
+let _teslemetry_tesla_protocol_command_universal_message = require("@teslemetry/tesla-protocol/command/universal_message");
+let _teslemetry_tesla_protocol_command_signatures = require("@teslemetry/tesla-protocol/command/signatures");
+let _teslemetry_tesla_protocol_command_vcsec = require("@teslemetry/tesla-protocol/command/vcsec");
+let _teslemetry_tesla_protocol_command_errors = require("@teslemetry/tesla-protocol/command/errors");
+let _teslemetry_tesla_protocol_command_car_server = require("@teslemetry/tesla-protocol/command/car_server");
+let _teslemetry_tesla_protocol_command_common = require("@teslemetry/tesla-protocol/command/common");
+let _teslemetry_tesla_protocol_command_vehicle = require("@teslemetry/tesla-protocol/command/vehicle");
+// src/commands.ts
+const VOID = {};
+/** Maximum HMAC-personalized (re)send attempts for one logical command, matching the reference implementation. */
+const MAX_ATTEMPTS = 4;
+const TrunkFields = {
+	front: "frontTrunk",
+	rear: "rearTrunk"
+};
+/** Node's REST `Seats` values mapped onto the seat-heater oneof field they select. */
+const SeatHeaterFields = {
+	[require_const.Seats.FRONT_LEFT]: "carSeatFrontLeft",
+	[require_const.Seats.FRONT_RIGHT]: "carSeatFrontRight",
+	[require_const.Seats.REAR_LEFT]: "carSeatRearLeft",
+	[require_const.Seats.REAR_LEFT_BACK]: "carSeatRearLeftBack",
+	[require_const.Seats.REAR_CENTER]: "carSeatRearCenter",
+	[require_const.Seats.REAR_RIGHT]: "carSeatRearRight",
+	[require_const.Seats.REAR_RIGHT_BACK]: "carSeatRearRightBack",
+	[require_const.Seats.THIRD_LEFT]: "carSeatThirdRowLeft",
+	[require_const.Seats.THIRD_RIGHT]: "carSeatThirdRowRight"
+};
+const SeatHeaterLevels = [
+	"seatHeaterOff",
+	"seatHeaterLow",
+	"seatHeaterMed",
+	"seatHeaterHigh"
+];
+/** Seat cooling and auto-climate only cover the front seats on the wire protocol. */
+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
+};
+const SeatCoolerLevels = [
+	_teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerLevelE.HvacSeatCoolerLevel_Off,
+	_teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerLevelE.HvacSeatCoolerLevel_Low,
+	_teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerLevelE.HvacSeatCoolerLevel_Med,
+	_teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerLevelE.HvacSeatCoolerLevel_High
+];
+/** Keyed by the 1-indexed `AutoSeat` REST value, which equals the proto enum value. */
+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
+];
+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,
+	[require_const.ClimateModes.Dog]: _teslemetry_tesla_protocol_command_car_server.HvacClimateKeeperAction_ClimateKeeperActionE.ClimateKeeperAction_Dog,
+	[require_const.ClimateModes.Camp]: _teslemetry_tesla_protocol_command_car_server.HvacClimateKeeperAction_ClimateKeeperActionE.ClimateKeeperAction_Camp
+};
+/** `set_cop_temp` accepts either the enum index or the Celsius/Fahrenheit value it represents. */
+const CopActivationTemps = {
+	0: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempLow,
+	30: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempLow,
+	90: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempLow,
+	1: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempMedium,
+	35: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempMedium,
+	95: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempMedium,
+	2: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempHigh,
+	40: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempHigh,
+	100: _teslemetry_tesla_protocol_command_vehicle.ClimateState_CopActivationTemp.CopActivationTempHigh
+};
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function ok(reason = "") {
+	return { response: {
+		result: true,
+		reason
+	} };
+}
+function fail(reason) {
+	return { response: {
+		result: false,
+		reason
+	} };
+}
+/**
+* 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.
+*
+* AES-GCM personalized signing (the BLE-only auth mode) is intentionally out
+* of scope here; see AGENTS.md.
+*/
+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;
+	fromDestination;
+	sessions;
+	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);
+		this.fromDestination = crypto.default.randomBytes(16);
+		const deriveKey = (vehiclePublicKey) => require_crypto.deriveSharedKey(this.#privateKey, 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)
+		};
+	}
+	sessionFor(domain) {
+		const session = this.sessions[domain];
+		if (!session) throw new Error(`No signed-command session configured for domain ${domain}.`);
+		return session;
+	}
+	/**
+	* 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.
+	*
+	* 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 -
+	* including its own whitelist-status field - and even then `Session.commit`
+	* still refuses a clock time that regresses within the same epoch.
+	*/
+	validateAndUpdateSession(resp, requestUuid) {
+		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.");
+			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));
+			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([
+				Buffer.from([
+					_teslemetry_tesla_protocol_command_signatures.Tag.TAG_SIGNATURE_TYPE,
+					1,
+					_teslemetry_tesla_protocol_command_signatures.SignatureType.SIGNATURE_TYPE_HMAC
+				]),
+				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_CHALLENGE, requestUuid.length]),
+				requestUuid,
+				Buffer.from([_teslemetry_tesla_protocol_command_signatures.Tag.TAG_END])
+			]);
+			const expectedTag = crypto.default.createHmac("sha256", keys.sessionInfoKey).update(Buffer.concat([metadata, Buffer.from(resp.sessionInfo)])).digest();
+			const receivedTag = Buffer.from(tag);
+			if (expectedTag.length !== receivedTag.length || !crypto.default.timingSafeEqual(expectedTag, receivedTag)) throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply failed authentication (invalid tag); discarded.");
+			if (info.status === _teslemetry_tesla_protocol_command_signatures.SessionInfoStatus.SESSION_INFO_STATUS_KEY_NOT_ON_WHITELIST) throw new require_exceptions.NotOnWhitelistFault();
+			if (!session.commit(info, keys)) throw new require_exceptions.SessionInfoAuthenticationFault("Session info reply is stale (clock regressed within the same epoch); discarded.");
+		}
+		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({
+			toDestination: { domain },
+			fromDestination: { routingAddress: this.fromDestination },
+			sessionInfoRequest: { publicKey: this.#publicKey },
+			uuid: crypto.default.randomBytes(16)
+		});
+		await this._send(msg, "session_info");
+	}
+	buildHmacMessage(session, command) {
+		const personalized = session.hmacPersonalized();
+		if (!session.hmacKey) throw new Error("Session HMAC key is missing.");
+		const metadata = Buffer.concat([
+			Buffer.from([
+				_teslemetry_tesla_protocol_command_signatures.Tag.TAG_SIGNATURE_TYPE,
+				1,
+				_teslemetry_tesla_protocol_command_signatures.SignatureType.SIGNATURE_TYPE_HMAC_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_END])
+		]);
+		const tag = crypto.default.createHmac("sha256", session.hmacKey).update(Buffer.concat([metadata, command])).digest();
+		return _teslemetry_tesla_protocol_command_universal_message.RoutableMessage.create({
+			toDestination: { domain: session.domain },
+			fromDestination: { routingAddress: this.fromDestination },
+			protobufMessageAsBytes: command,
+			uuid: crypto.default.randomBytes(16),
+			signatureData: {
+				signerIdentity: _teslemetry_tesla_protocol_command_signatures.KeyIdentity.create({ publicKey: this.#publicKey }),
+				HMACPersonalizedData: {
+					...personalized,
+					tag
+				}
+			}
+		});
+	}
+	/**
+	* Build, sign, dispatch (with WAIT/epoch-fault retry), and interpret one
+	* domain command.
+	*
+	* VCSEC requires messages to arrive in strict counter order and warns
+	* clients to avoid simultaneous requests to it at all (unlike
+	* Infotainment, which tolerates a sliding window) - so for
+	* `DOMAIN_VEHICLE_SECURITY` the *entire* dispatch (handshake, build,
+	* send, and any retry) runs under the domain's lock, guaranteeing at
+	* most one VCSEC message is ever in flight. Infotainment keeps the
+	* narrower build-only lock, serializing only counter assignment.
+	*/
+	async dispatch(domain, command, expectsData) {
+		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));
+				let resp;
+				try {
+					resp = await this._send(msg, "protobuf_message_as_bytes", expectsData);
+				} catch (error) {
+					if ((error instanceof require_exceptions.TeslaFleetMessageFaultIncorrectEpoch || error instanceof require_exceptions.TeslaFleetMessageFaultInvalidTokenOrCounter) && attempt < 3) continue;
+					throw error;
+				}
+				if (resp.signedMessageStatus?.operationStatus === _teslemetry_tesla_protocol_command_universal_message.OperationStatusE.OPERATIONSTATUS_WAIT) {
+					if (attempt >= 3) return fail("Too many retries");
+					await sleep(this.retryDelayMs);
+					continue;
+				}
+				const result = this.interpretResponse(resp);
+				if (result === "wait") {
+					if (attempt >= 3) return fail("Too many retries");
+					await sleep(this.retryDelayMs);
+					continue;
+				}
+				return result;
+			}
+			return fail("Too many retries");
+		};
+		return serializeWholeDispatch ? session.withLock(run) : run();
+	}
+	interpretResponse(resp) {
+		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_INFOTAINMENT) return this.interpretInfotainmentResponse(resp.protobufMessageAsBytes);
+		return ok();
+	}
+	interpretVcsecResponse(bytes) {
+		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.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) });
+			}
+		}
+		return ok();
+	}
+	interpretInfotainmentResponse(bytes) {
+		const response = _teslemetry_tesla_protocol_command_car_server.Response.decode(bytes);
+		if (response.ping) return ok(String(response.ping.localTimestamp ?? ""));
+		if (response.actionStatus) return { response: {
+			result: response.actionStatus.result === _teslemetry_tesla_protocol_command_car_server.OperationStatusE.OPERATIONSTATUS_OK,
+			reason: response.actionStatus.resultReason?.plainText ?? ""
+		} };
+		return ok();
+	}
+	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);
+	}
+	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);
+	}
+	vehicleAction(action) {
+		return this.sendInfotainment(_teslemetry_tesla_protocol_command_car_server.Action.create({ vehicleAction: action }));
+	}
+	resolveSeat(seat_position) {
+		return typeof seat_position === "string" ? require_const.Seats[seat_position] : seat_position;
+	}
+	/**
+	* Controls the front (which_trunk: "front") or rear (which_trunk: "rear") trunk.
+	* @param which_trunk "front" or "rear"
+	*/
+	async actuate_truck(which_trunk) {
+		const field = TrunkFields[which_trunk];
+		if (!field) throw new Error(`Invalid trunk: ${which_trunk}`);
+		const closureMoveRequest = {};
+		closureMoveRequest[field] = _teslemetry_tesla_protocol_command_vcsec.ClosureMoveTypeE.CLOSURE_MOVE_TYPE_MOVE;
+		return this.sendVehicleSecurity(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.create({ closureMoveRequest: _teslemetry_tesla_protocol_command_vcsec.ClosureMoveRequest.create(closureMoveRequest) }));
+	}
+	/**
+	* Adjusts vehicle media playback volume.
+	* @param volume A floating point number from 0.0 to 11.0.
+	*/
+	async adjust_volume(volume) {
+		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. */
+	async auto_conditioning_start() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacAutoAction: _teslemetry_tesla_protocol_command_car_server.HvacAutoAction.create({ powerOn: true }) }));
+	}
+	/** Stops climate preconditioning. */
+	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 }) }));
+	}
+	/** 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({}) }));
+	}
+	/** 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 }) }));
+	}
+	/** Closes the charge port door. */
+	async charge_port_door_close() {
+		return this.sendVehicleSecurity(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.create({ closureMoveRequest: _teslemetry_tesla_protocol_command_vcsec.ClosureMoveRequest.create({ chargePort: _teslemetry_tesla_protocol_command_vcsec.ClosureMoveTypeE.CLOSURE_MOVE_TYPE_CLOSE }) }));
+	}
+	/** Opens the charge port door. */
+	async charge_port_door_open() {
+		return this.sendVehicleSecurity(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.create({ closureMoveRequest: _teslemetry_tesla_protocol_command_vcsec.ClosureMoveRequest.create({ chargePort: _teslemetry_tesla_protocol_command_vcsec.ClosureMoveTypeE.CLOSURE_MOVE_TYPE_OPEN }) }));
+	}
+	/** Charges in Standard mode. */
+	async charge_standard() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ chargingStartStopAction: _teslemetry_tesla_protocol_command_car_server.ChargingStartStopAction.create({ startStandard: VOID }) }));
+	}
+	/** Starts charging the vehicle. */
+	async charge_start() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ chargingStartStopAction: _teslemetry_tesla_protocol_command_car_server.ChargingStartStopAction.create({ start: VOID }) }));
+	}
+	/** Stops charging the vehicle. */
+	async charge_stop() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ chargingStartStopAction: _teslemetry_tesla_protocol_command_car_server.ChargingStartStopAction.create({ stop: VOID }) }));
+	}
+	/**
+	* 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.
+	*/
+	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({}) }));
+	}
+	/** Locks the vehicle. */
+	async door_lock() {
+		return this.sendVehicleSecurity(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.create({ RKEAction: _teslemetry_tesla_protocol_command_vcsec.RKEActionE.RKE_ACTION_LOCK }));
+	}
+	/** Unlocks the vehicle. */
+	async door_unlock() {
+		return this.sendVehicleSecurity(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.create({ RKEAction: _teslemetry_tesla_protocol_command_vcsec.RKEActionE.RKE_ACTION_UNLOCK }));
+	}
+	/** Erases user's data from the user interface. Requires the vehicle to be in park. */
+	async erase_user_data() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ eraseUserDataAction: _teslemetry_tesla_protocol_command_car_server.EraseUserDataAction.create({}) }));
+	}
+	/** Briefly flashes the vehicle headlights. Requires the vehicle to be in park. */
+	async flash_lights() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlFlashLightsAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlFlashLightsAction.create({}) }));
+	}
+	/**
+	* Restricts certain vehicle UI functionality from guest users
+	* @param enable `true` or `false`
+	*/
+	async guest_mode(enable) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ guestModeAction: _teslemetry_tesla_protocol_command_vehicle.VehicleState_GuestMode.create({ GuestModeActive: enable }) }));
+	}
+	/** Honks the vehicle horn. Requires the vehicle to be in park. */
+	async honk_horn() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlHonkHornAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlHonkHornAction.create({}) }));
+	}
+	/** Advances media player to next favorite track. */
+	async media_next_fav() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ mediaNextFavorite: {} }));
+	}
+	/** Advances media player to next track. */
+	async media_next_track() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ mediaNextTrack: {} }));
+	}
+	/** Advances media player to previous favorite track. */
+	async media_prev_fav() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ mediaPreviousFavorite: {} }));
+	}
+	/** Advances media player to previous track. */
+	async media_prev_track() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ mediaPreviousTrack: {} }));
+	}
+	/** Toggles current play/pause state. */
+	async media_toggle_playback() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ mediaPlayAction: {} }));
+	}
+	/** Turns the volume down by one. */
+	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 }) }));
+	}
+	/**
+	* Start navigation to given coordinates.
+	* @param lat Latitude
+	* @param lon Longitude
+	* @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_request(lat, lon, order = 0) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ navigationGpsRequest: _teslemetry_tesla_protocol_command_car_server.NavigationGpsRequest.create({
+			lat,
+			lon,
+			order
+		}) }));
+	}
+	/**
+	* 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.
+	* @param value Destination text
+	*/
+	async navigation_request(value, _locale, _type) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ navigationRequest: _teslemetry_tesla_protocol_command_car_server.NavigationRequest.create({ destination: value }) }));
+	}
+	/**
+	* Start navigation to a supercharger.
+	* @param id Supercharger ID
+	* @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_sc_request(id, order) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ navigationSuperchargerRequest: _teslemetry_tesla_protocol_command_car_server.NavigationSuperchargerRequest.create({
+			id,
+			remoteNavTripOrder: order ?? 0
+		}) }));
+	}
+	/**
+	* 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)
+	* @param auto_climate_on `true` or `false`
+	*/
+	async remote_auto_seat_climate_request(auto_seat_position, auto_climate_on) {
+		const position = AutoSeatPositions[typeof auto_seat_position === "string" ? require_const.AutoSeat[auto_seat_position] : auto_seat_position];
+		if (position === void 0) throw new Error(`Invalid seat position for auto seat climate: ${auto_seat_position}`);
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ autoSeatClimateAction: _teslemetry_tesla_protocol_command_car_server.AutoSeatClimateAction.create({ carseat: [_teslemetry_tesla_protocol_command_car_server.AutoSeatClimateAction_CarSeat.create({
+			on: auto_climate_on,
+			seatPosition: position
+		})] }) }));
+	}
+	/**
+	* Sets automatic steering wheel heating on/off.
+	* @param on `true` or `false`
+	*/
+	async remote_auto_steering_wheel_heat_climate_request(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ autoStwHeatAction: _teslemetry_tesla_protocol_command_car_server.AutoStwHeatAction.create({ on }) }));
+	}
+	/**
+	* Plays a sound through the vehicle external speaker.
+	* @param sound Fart is `0`, Locate ping is `2000`
+	*/
+	async remote_boombox(sound = 0) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ boomboxAction: _teslemetry_tesla_protocol_command_car_server.BoomboxAction.create({ sound }) }));
+	}
+	/**
+	* Sets seat cooling. Only the front seats support this action.
+	* @param seat_position Seat position
+	* @param seat_cooler_level Cooling level
+	*/
+	async remote_seat_cooler_request(seat_position, seat_cooler_level) {
+		const position = SeatCoolerPositions[this.resolveSeat(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}`);
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacSeatCoolerActions: _teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions.create({ hvacSeatCoolerAction: [_teslemetry_tesla_protocol_command_car_server.HvacSeatCoolerActions_HvacSeatCoolerAction.create({
+			seatCoolerLevel: level,
+			seatPosition: position
+		})] }) }));
+	}
+	/**
+	* Sets seat heating.
+	* @param seat_position Seat position
+	* @param seat_heater_level Heating level
+	*/
+	async remote_seat_heater_request(seat_position, seat_heater_level) {
+		const field = SeatHeaterFields[this.resolveSeat(seat_position)];
+		if (!field) throw new Error(`Invalid seat position: ${seat_position}`);
+		const levelField = SeatHeaterLevels[seat_heater_level];
+		if (!levelField) throw new Error(`Invalid seat heater level: ${seat_heater_level}`);
+		const heaterAction = {};
+		heaterAction[field] = VOID;
+		heaterAction[levelField] = VOID;
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacSeatHeaterActions: _teslemetry_tesla_protocol_command_car_server.HvacSeatHeaterActions.create({ hvacSeatHeaterAction: [_teslemetry_tesla_protocol_command_car_server.HvacSeatHeaterActions_HvacSeatHeaterAction.create(heaterAction)] }) }));
+	}
+	/** Starts the vehicle remotely. Requires keyless driving to be enabled. */
+	async remote_start_drive() {
+		return this.sendVehicleSecurity(_teslemetry_tesla_protocol_command_vcsec.UnsignedMessage.create({ RKEAction: _teslemetry_tesla_protocol_command_vcsec.RKEActionE.RKE_ACTION_REMOTE_DRIVE }));
+	}
+	/**
+	* Sets steering wheel heat level.
+	* @param level Heating level (0=Off, 1=Low, 2=High)
+	*/
+	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}`);
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ stwHeatLevelAction: _teslemetry_tesla_protocol_command_car_server.StwHeatLevelAction.create({ stwHeatLevel: stwLevel }) }));
+	}
+	/**
+	* Sets steering wheel heating on/off. For vehicles that do not support auto steering wheel heat.
+	* @param on `true` or `false`
+	*/
+	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 }) }));
+	}
+	/** 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({}) }));
+	}
+	/** Removes PIN for Valet Mode. */
+	async reset_valet_pin() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlResetValetPinAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlResetValetPinAction.create({}) }));
+	}
+	/**
+	* Schedules a vehicle software update (over the air "OTA") to be installed in the future.
+	* @param offset_sec Offset in seconds
+	*/
+	async schedule_software_update(offset_sec) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlScheduleSoftwareUpdateAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlScheduleSoftwareUpdateAction.create({ offsetSec: offset_sec }) }));
+	}
+	/**
+	* Turns Bioweapon Defense Mode on and off.
+	* @param on `true` or `false`
+	* @param manual_override `true` or `false`
+	*/
+	async set_bioweapon_mode(on, manual_override) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacBioweaponModeAction: _teslemetry_tesla_protocol_command_car_server.HvacBioweaponModeAction.create({
+			on,
+			manualOverride: manual_override
+		}) }));
+	}
+	/**
+	* Sets the vehicle overheat protection.
+	* @param on `true` or `false`
+	* @param fan_only `true` or `false`
+	*/
+	async set_cabin_overheat_protection(on, fan_only) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setCabinOverheatProtectionAction: _teslemetry_tesla_protocol_command_car_server.SetCabinOverheatProtectionAction.create({
+			on,
+			fanOnly: fan_only
+		}) }));
+	}
+	/**
+	* Sets the vehicle's charge limit to a custom percentage.
+	* @param percent Charge limit percentage typically between 50-100
+	*/
+	async set_charge_limit(percent) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ chargingSetLimitAction: _teslemetry_tesla_protocol_command_car_server.ChargingSetLimitAction.create({ percent }) }));
+	}
+	/**
+	* Sets the charging amps.
+	* @param charging_amps Current limit in Amps typically between 5-32
+	*/
+	async set_charging_amps(charging_amps) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setChargingAmpsAction: _teslemetry_tesla_protocol_command_car_server.SetChargingAmpsAction.create({ chargingAmps: charging_amps }) }));
+	}
+	/**
+	* Enables climate keeper mode.
+	* @param climate_keeper_mode `0` is Off, `1` is Keep, `2` is Dog, `3` is Camp
+	*/
+	async set_climate_keeper_mode(climate_keeper_mode) {
+		const mode = typeof climate_keeper_mode === "string" ? require_const.ClimateModes[climate_keeper_mode] : climate_keeper_mode;
+		const action = ClimateKeeperActions[mode];
+		if (action === void 0) throw new Error(`Invalid climate keeper mode: ${climate_keeper_mode}`);
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacClimateKeeperAction: {
+			ClimateKeeperAction: action,
+			manualOverride: false,
+			manualOverrideMode: []
+		} }));
+	}
+	/**
+	* Adjusts the Cabin Overheat Protection temperature (COP).
+	* @param cop_temp Integer representing Low (0/30C/90F), Medium (1/35C/95F), or High (2/40C/100F)
+	*/
+	async set_cop_temp(cop_temp) {
+		const copActivationTemp = CopActivationTemps[cop_temp];
+		if (copActivationTemp === void 0) throw new Error(`Invalid cop_temp: ${cop_temp}`);
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setCopTempAction: _teslemetry_tesla_protocol_command_car_server.SetCopTempAction.create({ copActivationTemp }) }));
+	}
+	/**
+	* Sets a four-digit passcode for PIN to Drive.
+	* @param on `true` or `false`
+	* @param password Four-digit passcode
+	*/
+	async set_pin_to_drive(on, password) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlSetPinToDriveAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlSetPinToDriveAction.create({
+			on,
+			password: String(password)
+		}) }));
+	}
+	/**
+	* Sets an override for preconditioning — it should default to empty if no override is used.
+	* @param on `true` or `false`
+	* @param manual_override `true` or `false`
+	*/
+	async set_preconditioning_max(on, manual_override) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacSetPreconditioningMaxAction: _teslemetry_tesla_protocol_command_car_server.HvacSetPreconditioningMaxAction.create({
+			on,
+			manualOverride: manual_override
+		}) }));
+	}
+	/**
+	* Sets a time at which charging should be completed.
+	* @param enable `true` or `false`
+	* @param time Minutes after midnight
+	*/
+	async set_scheduled_charging(enable, time) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ scheduledChargingAction: _teslemetry_tesla_protocol_command_car_server.ScheduledChargingAction.create({
+			enabled: enable,
+			chargingTime: time
+		}) }));
+	}
+	/**
+	* 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.
+	* @param enable `true` or `false`
+	* @param preconditioning_enabled not representable in a signed command
+	* @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_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 });
+		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,
+			preconditioningTimes,
+			offPeakChargingTimes,
+			offPeakHoursEndTime: end_off_peak_time
+		}) }));
+	}
+	/**
+	* Enables and disables Sentry Mode.
+	* @param on `true` or `false`
+	*/
+	async set_sentry_mode(on) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlSetSentryModeAction: _teslemetry_tesla_protocol_command_car_server.VehicleControlSetSentryModeAction.create({ on }) }));
+	}
+	/**
+	* 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
+	*/
+	async set_temps(driver_temp, passenger_temp) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ hvacTemperatureAdjustmentAction: _teslemetry_tesla_protocol_command_car_server.HvacTemperatureAdjustmentAction.create({
+			driverTempCelsius: driver_temp,
+			passengerTempCelsius: passenger_temp
+		}) }));
+	}
+	/**
+	* Turns on Valet Mode and sets a four-digit passcode.
+	* @param on `true` or `false`
+	* @param password Four-digit passcode
+	*/
+	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)
+		}) }));
+	}
+	/**
+	* Changes the name of a vehicle.
+	* @param vehicle_name New name
+	*/
+	async set_vehicle_name(vehicle_name) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ setVehicleNameAction: _teslemetry_tesla_protocol_command_car_server.SetVehicleNameAction.create({ vehicleName: vehicle_name }) }));
+	}
+	/**
+	* Activates Speed Limit Mode with a four-digit PIN.
+	* @param pin Four-digit PIN
+	*/
+	async speed_limit_activate(pin) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ drivingSpeedLimitAction: _teslemetry_tesla_protocol_command_car_server.DrivingSpeedLimitAction.create({
+			activate: true,
+			pin: String(pin)
+		}) }));
+	}
+	/**
+	* Deactivates Speed Limit Mode and resets the associated PIN.
+	* @param pin Four-digit PIN
+	*/
+	async speed_limit_clear_pin(pin) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ drivingClearSpeedLimitPinAction: _teslemetry_tesla_protocol_command_car_server.DrivingClearSpeedLimitPinAction.create({ pin: String(pin) }) }));
+	}
+	/** Deactivates Speed Limit Mode and resets the associated PIN, for fleet managers or owners. */
+	async speed_limit_clear_pin_admin() {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ drivingClearSpeedLimitPinAdminAction: _teslemetry_tesla_protocol_command_car_server.DrivingClearSpeedLimitPinAdminAction.create({}) }));
+	}
+	/**
+	* Deactivates Speed Limit Mode.
+	* @param pin Four-digit PIN
+	*/
+	async speed_limit_deactivate(pin) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ drivingSpeedLimitAction: _teslemetry_tesla_protocol_command_car_server.DrivingSpeedLimitAction.create({
+			activate: false,
+			pin: String(pin)
+		}) }));
+	}
+	/**
+	* Sets the maximum speed allowed when Speed Limit Mode is active.
+	* @param limit_mph Maximum speed in MPH
+	*/
+	async speed_limit_set_limit(limit_mph) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ drivingSetSpeedLimitAction: _teslemetry_tesla_protocol_command_car_server.DrivingSetSpeedLimitAction.create({ limitMph: limit_mph }) }));
+	}
+	/**
+	* 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"
+	*/
+	async sun_roof_control(state) {
+		let action;
+		if (state === "vent") action = _teslemetry_tesla_protocol_command_car_server.VehicleControlSunroofOpenCloseAction.create({ vent: 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 }));
+	}
+	/**
+	* Records a drive note. 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 endpoint on vehicles that
+	* require signing.
+	* @param note Drive note
+	*/
+	async take_drivenote(note) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ takeDrivenoteAction: _teslemetry_tesla_protocol_command_car_server.TakeDrivenoteAction.create({ note }) }));
+	}
+	/**
+	* Turns on HomeLink (used to open and close garage doors).
+	* @param lat Latitude
+	* @param lon Longitude
+	* @param token
+	*/
+	async trigger_homelink(lat, lon, token = "") {
+		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({
+				latitude: lat,
+				longitude: lon
+			}),
+			token
+		}) }));
+	}
+	/**
+	* 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
+	* endpoint on vehicles that require signing.
+	* @param calendar_data Calendar data
+	*/
+	async upcoming_calendar_entries(calendar_data) {
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ uiSetUpcomingCalendarEntries: _teslemetry_tesla_protocol_command_car_server.UiSetUpcomingCalendarEntries.create({ calendarData: calendar_data }) }));
+	}
+	/**
+	* 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 });
+		return this.vehicleAction(_teslemetry_tesla_protocol_command_car_server.VehicleAction.create({ vehicleControlWindowAction: action }));
+	}
+};
+exports.default = Commands;