tesla-fleet-api 0.4.0 → 0.5.0

package/dist/teslemetryenergy.mjs

@@ -0,0 +1,282 @@
+import { AuthorizedClientState, EnergyDeviceIdentifierType } from "./const.mjs";
+import Energy from "./energy.mjs";
+import { validate_island_mode } from "./energyisland.mjs";
+import { parse_authorized_clients, parse_gateway_address } from "./energyparsers.mjs";
+import EnergySpecific, { backupSchedulingInfo, publicKeyBase64, raise_on_island_rejection, validate_dispatch_battery_power } from "./energyspecific.mjs";
+import { AuthorizedClientPairingTimedOut, AuthorizedClientWaitExpired } from "./exceptions.mjs";
+// src/teslemetryenergy.ts
+/** Default overall bound on `wait_until_paired`, in milliseconds. */
+const DEFAULT_PAIRING_TIMEOUT = 6e5;
+/** Default delay between `wait_until_paired` polls, in milliseconds. */
+const DEFAULT_PAIRING_POLL_INTERVAL = 5e3;
+const EXPIRED = Symbol("expired");
+/**
+* Settle as `step` does, or resolve `EXPIRED` after `ms`, or reject with the
+* signal's reason. JavaScript cannot cancel `step`, so one that outlives this
+* is abandoned, and its late rejection stays handled here.
+*/
+function settleWithin(step, ms, signal) {
+	return new Promise((resolve, reject) => {
+		const finish = (settle) => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			settle();
+		};
+		const onAbort = () => finish(() => reject(signal?.reason));
+		const timer = setTimeout(() => finish(() => resolve(EXPIRED)), ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		Promise.resolve().then(step).then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+	});
+}
+/**
+* Teslemetry's energy site.
+*
+* With a signing key (see `EnergySpecific`), every device command except the
+* four pre-pairing reads is signed with that key and sent through Teslemetry's
+* `device_command` route. Without a key, a command uses its Teslemetry route.
+* The `set_island_mode`, `backup_events` and `config` routes sign with
+* Teslemetry's own key, which must be verified on the gateway, or the route
+* answers 409 `energy_site_not_paired` and sends nothing. As of 2026-10-29 the
+* `dispatch_battery_power`, `resume_battery_operation` and backup-event
+* schedule and cancel routes still send unsigned, so Tesla answers HTTP 400:
+* keyless dispatch does not work until Teslemetry signs those routes.
+*/
+var TeslemetryEnergySite = class extends EnergySpecific {
+	/** Send a signed `RoutableMessage` through Teslemetry's route, which takes the flat body and adds Tesla's `data` wrapper itself. */
+	async _device_command(routable_message, target_id, identifier_type = EnergyDeviceIdentifierType.GATEWAY_DIN) {
+		return this.parent.parent._request("POST", `api/1/energy_sites/${this.energy_site_id}/device_command`, null, this._device_command_body(routable_message, target_id, identifier_type));
+	}
+	/** `GET` a Teslemetry command route. */
+	async _get_route(route) {
+		return this.parent.parent._request("GET", `api/1/energy_sites/${this.energy_site_id}/command/${route}`);
+	}
+	/** `POST` to a Teslemetry command route. */
+	async _post_route(route, json = null) {
+		return this.parent.parent._request("POST", `api/1/energy_sites/${this.energy_site_id}/command/${route}`, null, json);
+	}
+	/**
+	* Set the island mode on the energy gateway. With a signing key this signs
+	* the command with that key. Without one it calls the Teslemetry route, which
+	* signs it with Teslemetry's key. See `EnergySpecific.set_island_mode`.
+	*/
+	async set_island_mode(mode, force) {
+		validate_island_mode(mode, force);
+		if (this.signing) return super.set_island_mode(mode, force);
+		const result = await this._post_route("set_island_mode", force == null ? { mode } : {
+			mode,
+			force
+		});
+		raise_on_island_rejection(result);
+		return result;
+	}
+	/** Get backup events. Without a signing key, the Teslemetry route signs with Teslemetry's key. */
+	async get_backup_events() {
+		return this.signing ? super.get_backup_events() : this._get_route("backup_events");
+	}
+	/** Get the TEG configuration. Without a signing key, the Teslemetry route signs with Teslemetry's key. */
+	async get_teg_config() {
+		return this.signing ? super.get_teg_config() : this._get_route("config");
+	}
+	/** Get energy device system information. A pre-pairing read: never signed, even with a key. */
+	async get_system_info() {
+		return this._get_route("system_info");
+	}
+	/** Get networking status, which Teslemetry returns already unwrapped. A pre-pairing read: never signed, even with a key. */
+	async raw_networking_status() {
+		return this._get_route("networking_status");
+	}
+	/** Scan for WiFi networks on the energy gateway. */
+	async wifi_scan() {
+		return this.signing ? super.wifi_scan() : this._get_route("wifi_scan");
+	}
+	/** Get the energy device certificate. */
+	async get_device_cert() {
+		return this.signing ? super.get_device_cert() : this._get_route("device_cert");
+	}
+	/** Get cellular modem information. Without a signing key, the Teslemetry route signs with Teslemetry's key. */
+	async get_cellular_info() {
+		return this.signing ? super.get_cellular_info() : this._get_route("cellular_info");
+	}
+	/** Check for a firmware update. Without a signing key, the Teslemetry route signs with Teslemetry's key. */
+	async check_for_update() {
+		return this.signing ? super.check_for_update() : this._get_route("check_for_update");
+	}
+	/** Check the urgency of any firmware update. Without a signing key, the Teslemetry route signs with Teslemetry's key. */
+	async check_for_update_urgency() {
+		return this.signing ? super.check_for_update_urgency() : this._get_route("check_for_update_urgency");
+	}
+	/** Test internet connectivity on the energy gateway. Without a signing key, the Teslemetry route signs with Teslemetry's key. */
+	async check_internet() {
+		return this.signing ? super.check_internet() : this._get_route("check_internet");
+	}
+	/**
+	* Update local site configuration on the energy gateway. This writes gateway
+	* configuration and is an undocumented energy device gRPC command.
+	* @param params Raw protobuf request fields.
+	*/
+	async set_local_site_config(params) {
+		return this.signing ? super.set_local_site_config(params) : this._post_route("set_local_site_config", params ?? {});
+	}
+	/** Get the gateway's signed commands public key. A pre-pairing read: never signed, even with a key. */
+	async get_signed_commands_public_key() {
+		return this._get_route("signed_commands_public_key");
+	}
+	/**
+	* Schedule a manual backup event on the energy gateway.
+	* @param start_time ISO 8601 timestamp for when the backup event should start.
+	* @param duration_seconds Duration of the backup event in seconds.
+	* @param priority Priority level for the backup event. A string carries values beyond 2^53.
+	*/
+	async schedule_backup_event(start_time, duration_seconds, priority) {
+		if (this.signing) return super.schedule_backup_event(start_time, duration_seconds, priority);
+		const scheduling_info = backupSchedulingInfo(start_time, duration_seconds, priority);
+		return this._post_route("schedule_backup_event", scheduling_info ? { scheduling_info } : {});
+	}
+	/** Cancel a scheduled backup event on the energy gateway. */
+	async cancel_backup_event() {
+		return this.signing ? super.cancel_backup_event() : this._post_route("cancel_backup_event", {});
+	}
+	/**
+	* Register an authorized client with the energy gateway. All arguments are
+	* optional: if omitted, the Teslemetry server fills in its own key details. A
+	* site with a signing key signs the request with that key when `public_key`
+	* is given. Without a public key the route registers Teslemetry's own key,
+	* which the client key cannot sign for.
+	* @param public_key Raw DER bytes in the encoding matching `key_type` (RSA PKCS#1 or ECC SPKI), which are base64-encoded, or an already base64-encoded string.
+	* @param description Human-readable description of the client.
+	* @param key_type The type of key being registered.
+	* @param authorized_client_type The authorized client type.
+	*/
+	async add_authorized_client(public_key, description, key_type, authorized_client_type) {
+		if (this.signing && public_key != null) return super.add_authorized_client(public_key, description ?? void 0, key_type ?? void 0, authorized_client_type ?? void 0);
+		return this._post_route("add_authorized_client", {
+			public_key: public_key == null ? null : publicKeyBase64(public_key),
+			description,
+			key_type,
+			authorized_client_type
+		});
+	}
+	/** Get networking status from the gateway's Teslemetry route, including WiFi, Ethernet, and cellular details. */
+	async get_networking_status() {
+		return this._get_route("networking_status");
+	}
+	/**
+	* Discover the gateway's LAN IPv4 address, for pre-filling a local control
+	* host. See `parse_gateway_address` for the selection rule.
+	* @returns The address, or `null` when the reply is well-formed but no interface yields one.
+	* @throws InvalidResponse on a null body or an unrecognized reply.
+	* @throws EnergyGatewayUnreachable when Teslemetry cannot reach the gateway.
+	*/
+	async find_gateway_address() {
+		return parse_gateway_address(await this.get_networking_status());
+	}
+	/**
+	* List authorized clients on the energy gateway. Teslemetry may return JSON
+	* `null` when no payload is available; that value is returned unchanged.
+	*/
+	async list_authorized_clients() {
+		return this._get_route("authorized_clients");
+	}
+	/**
+	* List authorized clients on the energy gateway, parsed into a typed result.
+	* For the unparsed reply, use `list_authorized_clients`.
+	* @throws InvalidResponse on a null body or an unrecognized reply, rather than treating either as "no clients".
+	*/
+	async find_authorized_clients() {
+		return parse_authorized_clients(await this.list_authorized_clients());
+	}
+	/**
+	* Remove an authorized client from the energy gateway. A site with a signing
+	* key signs the request with that key. Removal needs no physical presence
+	* proof, so any paired key can revoke every other key, including the owner's.
+	* @param public_key Raw DER bytes, which are base64-encoded, or an already base64-encoded string as `list_authorized_clients` reports it.
+	*/
+	async remove_authorized_client(public_key) {
+		if (this.signing) return super.remove_authorized_client(public_key);
+		return this._post_route("remove_authorized_client", { public_key: publicKeyBase64(public_key) });
+	}
+	/**
+	* Request a timed battery power setpoint on the energy gateway. Without a
+	* signing key the Teslemetry route still sends unsigned and gets Tesla's HTTP
+	* 400 (2026-10-29). See `EnergySpecific.dispatch_battery_power`.
+	* @param power_watts Battery power in watts: positive discharges, negative charges.
+	* @param duration_seconds Whole seconds from 1 to 86400.
+	*/
+	async dispatch_battery_power(power_watts, duration_seconds) {
+		if (this.signing) return super.dispatch_battery_power(power_watts, duration_seconds);
+		validate_dispatch_battery_power(power_watts, duration_seconds);
+		return this._post_route("dispatch_battery_power", {
+			power_watts,
+			duration_seconds
+		});
+	}
+	/**
+	* Release a `dispatch_battery_power` setpoint. Without a signing key the
+	* Teslemetry route still sends unsigned and gets Tesla's HTTP 400 (2026-10-29).
+	*/
+	async resume_battery_operation() {
+		return this.signing ? super.resume_battery_operation() : this._post_route("resume_battery_operation");
+	}
+	/**
+	* Wait for a key already registered with `add_authorized_client` to finish
+	* pairing, polling `find_authorized_clients` until its entry is `VERIFIED`.
+	*
+	* The gateway's presence-proof window is about 9 minutes, and a breaker toggle
+	* confirmed a key in as little as 59 s, with no cloud auto-verify observed.
+	* A poll that fails counts as no signal.
+	* @param public_key The key as passed to `add_authorized_client`, raw DER bytes or base64.
+	* @param options.verify_by_use A signed local read. Once the cloud reports `VERIFIED`, one successful call confirms the key is usable. A failure means "not yet" and polling continues, because `VERIFIED` can be seen slightly ahead of local usability.
+	* @param options.timeout_ms Overall bound on the wait.
+	* @param options.poll_interval_ms Delay between polls.
+	* @param options.signal Aborting rejects with the signal's reason. An in-flight call is abandoned, not cancelled.
+	* @returns The matched entry, once paired and confirmed.
+	* @throws AuthorizedClientPairingTimedOut at once on `PENDING_VERIFICATION_TIMEOUT`. The registration is dead: call `add_authorized_client` again with the same key, which resets the window, then wait again.
+	* @throws AuthorizedClientWaitExpired when `timeout_ms` elapses first. The registration is still alive: wait again.
+	*/
+	async wait_until_paired(public_key, options = {}) {
+		const { verify_by_use, timeout_ms = DEFAULT_PAIRING_TIMEOUT, poll_interval_ms = DEFAULT_PAIRING_POLL_INTERVAL, signal } = options;
+		const target = publicKeyBase64(public_key);
+		const deadline = performance.now() + timeout_ms;
+		let last_state = null;
+		const expired = () => new AuthorizedClientWaitExpired({
+			public_key: target,
+			state: last_state
+		});
+		/** Run one step under the deadline. A failed step is `undefined`, unless the wait was aborted. */
+		const attempt = async (step) => {
+			const result = await settleWithin(step, deadline - performance.now(), signal).catch((error) => {
+				if (signal?.aborted) throw error;
+			});
+			if (result === EXPIRED) throw expired();
+			return result;
+		};
+		while (true) {
+			signal?.throwIfAborted();
+			if (performance.now() >= deadline) throw expired();
+			const match = (await attempt(() => this.find_authorized_clients()))?.clients.find((client) => client.public_key === target);
+			if (match !== void 0) {
+				last_state = match.state;
+				if (match.state === AuthorizedClientState.PENDING_VERIFICATION_TIMEOUT) throw new AuthorizedClientPairingTimedOut({
+					public_key: target,
+					state: match.state
+				});
+				if (match.state === AuthorizedClientState.VERIFIED) {
+					if (verify_by_use === void 0) return match;
+					if (performance.now() >= deadline) throw expired();
+					if (await attempt(async () => (await verify_by_use(), true)) === true) return match;
+				}
+			}
+			const remaining = deadline - performance.now();
+			if (remaining <= 0) throw expired();
+			await settleWithin(() => new Promise(() => {}), Math.min(poll_interval_ms, remaining), signal);
+		}
+	}
+};
+/** Creates and holds Teslemetry energy sites. */
+var TeslemetryEnergySites = class extends Energy {
+	static Site = TeslemetryEnergySite;
+	create(energy_site_id, private_key, din) {
+		return super.create(energy_site_id, private_key, din);
+	}
+};
+export { DEFAULT_PAIRING_POLL_INTERVAL, DEFAULT_PAIRING_TIMEOUT, TeslemetryEnergySite, TeslemetryEnergySites, parse_authorized_clients, parse_gateway_address };

package/dist/teslemetryvehicle.cjs

@@ -0,0 +1,407 @@
+const require_const = require("./const.cjs");
+const require_exceptions = require("./exceptions.cjs");
+const require_vehicle = require("./vehicle.cjs");
+const require_vehiclespecific = require("./vehiclespecific.cjs");
+// src/teslemetryvehicle.ts
+/** A Teslemetry vehicle: the Fleet REST commands plus Teslemetry's `custom_command` routes. */
+var TeslemetryVehicle = class extends require_vehiclespecific.default {
+	_request(method, path, params, json) {
+		return this.parent.parent._request(method, path, params, json);
+	}
+	_custom_command(name, json) {
+		return this._request("POST", `api/1/vehicles/${this.vin}/custom_command/${name}`, null, json);
+	}
+	/**
+	* Get or set Auto mode.
+	* @deprecated Python marks this for removal in a future release.
+	* @param value `true` enables it, `false` disables it, omit to read it.
+	*/
+	async server_side_polling(value) {
+		this.parent.parent._log("This method is deprecated and will be removed in a future release.");
+		return this.parent.parent.server_side_polling(this.vin, value);
+	}
+	/** Force a refresh of the vehicle data. */
+	async data_refresh() {
+		return this.parent.parent.vehicle_data_refresh(this.vin);
+	}
+	/** Performs a no-op on the vehicle. */
+	async ping() {
+		return this._custom_command("ping");
+	}
+	/**
+	* Open, close, move and stop the vehicle's doors, frunk, trunk, charge port and tonneau.
+	* @example await vehicle.closure({ front_trunk: ClosureState.OPEN });
+	*/
+	async closure(options = {}) {
+		const keys = [
+			["frontDriverDoor", options.front_driver_door],
+			["frontPassengerDoor", options.front_passenger_door],
+			["rearDriverDoor", options.rear_driver_door],
+			["rearPassengerDoor", options.rear_passenger_door],
+			["rearTrunk", options.rear_trunk],
+			["frontTrunk", options.front_trunk],
+			["chargePort", options.charge_port],
+			["tonneau", options.tonneau]
+		];
+		return this._custom_command("closure", Object.fromEntries(keys.filter(([, state]) => state !== require_const.ClosureState.NONE)));
+	}
+	/** Opens the rear trunk; unlike `actuate_trunk`, never closes it. */
+	async open_rear_trunk() {
+		return this.closure({ rear_trunk: require_const.ClosureState.OPEN });
+	}
+	/** Closes the rear trunk; unlike `actuate_trunk`, never opens it. */
+	async close_rear_trunk() {
+		return this.closure({ rear_trunk: require_const.ClosureState.CLOSE });
+	}
+	/** Opens the tonneau cover. */
+	async open_tonneau() {
+		return this.closure({ tonneau: require_const.ClosureState.OPEN });
+	}
+	/** Closes the tonneau cover. */
+	async close_tonneau() {
+		return this.closure({ tonneau: require_const.ClosureState.CLOSE });
+	}
+	/** Stops the tonneau cover. */
+	async stop_tonneau() {
+		return this.closure({ tonneau: require_const.ClosureState.STOP });
+	}
+	/**
+	* Sets multiple seat heaters at once.
+	* @example await vehicle.seat_heater({ front_left: SeatHeaterLevel.HIGH });
+	*/
+	async seat_heater(options = {}) {
+		return this._custom_command("seat_heater", {
+			frontLeft: options.front_left,
+			frontRight: options.front_right,
+			rearLeft: options.rear_left,
+			rearRight: options.rear_right,
+			rearLeftBack: options.rear_left_back,
+			rearCenter: options.rear_center,
+			rearRightBack: options.rear_right_back,
+			thirdRowLeft: options.third_row_left,
+			thirdRowRight: options.third_row_right
+		});
+	}
+	/**
+	* Enable or disable charging on solar, and set its charge limits.
+	* @param enabled
+	* @param lower_charge_limit 0 to `upper_charge_limit`
+	* @param upper_charge_limit `lower_charge_limit` to 100
+	*/
+	async charge_on_solar(enabled, lower_charge_limit, upper_charge_limit) {
+		return this._custom_command("charge_on_solar", {
+			enabled,
+			lowerChargeLimit: lower_charge_limit,
+			upperChargeLimit: upper_charge_limit
+		});
+	}
+	/** Gets the current charge-on-solar settings. */
+	async get_charge_on_solar() {
+		return this._request("GET", `api/1/vehicles/${this.vin}/custom_command/charge_on_solar`);
+	}
+	/** Save the last 10 minutes of dashcam footage. */
+	async dashcam_save() {
+		return this._custom_command("dashcam_save");
+	}
+	/**
+	* Play a supported video URL in the vehicle.
+	* @param url Video URL, e.g. a YouTube URL.
+	*/
+	async play_video(url) {
+		return this._custom_command("play_video", { url });
+	}
+	/** Stop the currently playing light show. */
+	async stop_light_show() {
+		return this._custom_command("stop_light_show");
+	}
+	/**
+	* Start a light show on the vehicle.
+	* @param show_index Index of the light show to play.
+	* @param start_time Start time in milliseconds since epoch.
+	* @param volume Volume level for the light show.
+	* @param dance_moves Enable dance moves during the light show.
+	*/
+	async start_light_show(show_index, start_time, volume, dance_moves) {
+		return this._custom_command("start_light_show", {
+			show_index,
+			start_time,
+			volume,
+			dance_moves
+		});
+	}
+	/**
+	* Deactivates PIN to Drive.
+	* @param pin 4-digit PIN to clear.
+	*/
+	async clear_pin_to_drive(pin) {
+		return this._custom_command("clear_pin_to_drive", { pin });
+	}
+	/** Remove all impermanent keys from the vehicle. */
+	async remove_key() {
+		return this._custom_command("remove_key");
+	}
+	/**
+	* Sets the front zone light level. Named to match the signed sibling for router failover.
+	* @param level 0 off, 1 low, 2 medium, 3 high.
+	*/
+	async set_front_zone_lights(level) {
+		return this._custom_command("front_zone_light", { level });
+	}
+	/**
+	* Sets the rear zone light level. Named to match the signed sibling for router failover.
+	* @param level 0 off, 1 low, 2 medium, 3 high.
+	*/
+	async set_rear_zone_lights(level) {
+		return this._custom_command("rear_zone_light", { level });
+	}
+	/**
+	* Sets outlets on or off.
+	* @param request 0 off, 1 cabin and bed, 2 cabin.
+	*/
+	async set_outlets(request) {
+		return this._custom_command("set_outlets", { request });
+	}
+	/** Sets the outlet SOC limit percentage. */
+	async set_outlet_soc_limit(percent) {
+		return this._custom_command("set_outlet_soc_limit", { percent });
+	}
+	/**
+	* Sets power feed on or off.
+	* @param request 0 off, 1 feed 1, 2 feed 2, 3 both.
+	*/
+	async set_power_feed(request) {
+		return this._custom_command("set_power_feed", { request });
+	}
+	/** Sets the power feed SOC limit percentage. */
+	async set_power_feed_soc_limit(percent) {
+		return this._custom_command("set_power_feed_soc_limit", { percent });
+	}
+	/** Sets the lightbar brightness. */
+	async set_lightbar_brightness(brightness) {
+		return this._custom_command("set_lightbar_brightness", { brightness });
+	}
+	/** Enables or disables the lightbar middle light. */
+	async set_lightbar_middle(on) {
+		return this._custom_command("set_lightbar_middle", { on });
+	}
+	/** Enables or disables the ditch lights. */
+	async set_lightbar_ditch(on) {
+		return this._custom_command("set_lightbar_ditch", { on });
+	}
+	/** Starts or stops the trailer light test. */
+	async set_trailer_light_test(on) {
+		return this._custom_command("set_trailer_light_test", { on });
+	}
+	/** Sets the truck bed light auto state. */
+	async set_truck_bed_light_auto(on) {
+		return this._custom_command("set_truck_bed_light_auto", { on });
+	}
+	/** Sets the truck bed light brightness. */
+	async set_truck_bed_light_brightness(brightness) {
+		return this._custom_command("set_truck_bed_light_brightness", { brightness });
+	}
+	/** Enables or disables the Powershare feature. */
+	async set_powershare_feature(on) {
+		return this._custom_command("set_powershare_feature", { on });
+	}
+	/** Enables or disables an active Powershare session. */
+	async set_powershare_request(on) {
+		return this._custom_command("set_powershare_request", { on });
+	}
+	/** Sets the Powershare discharge limit percentage. */
+	async set_powershare_discharge_limit(percent) {
+		return this._custom_command("set_powershare_discharge_limit", { percent });
+	}
+	/** Sets HVAC recirculation on or off. Named to match the signed sibling for router failover. */
+	async set_recirculation(on) {
+		return this._custom_command("hvac_recirculation", { on });
+	}
+	/** Enables or disables tent mode. */
+	async set_tent_mode(on) {
+		return this._custom_command("set_tent_mode", { on });
+	}
+	/**
+	* Sets the suspension level.
+	* @param level 1 entry, 2 low, 3 medium, 4 high, 5 very high, 6 extract.
+	*/
+	async set_suspension_level(level) {
+		return this._custom_command("set_suspension_level", { level });
+	}
+	/** Turns Low Power mode on or off, reducing standby consumption while parked. */
+	async set_low_power_mode(on) {
+		return this._custom_command("set_low_power_mode", { on });
+	}
+	/** Turns Keep Accessory Power mode on or off, keeping 12V accessory power available while parked. */
+	async set_keep_accessory_power_mode(on) {
+		return this._custom_command("set_keep_accessory_power_mode", { on });
+	}
+	/** Sets the displayed temperature unit. */
+	async set_temperature_unit(unit) {
+		return this._custom_command("set_temperature_unit", { unit });
+	}
+	/** Sets the displayed distance unit. */
+	async set_distance_unit(unit) {
+		return this._custom_command("set_distance_unit", { unit });
+	}
+	/** Sets the displayed clock format (12h or 24h). */
+	async set_time_display_format(format) {
+		return this._custom_command("set_time_display_format", { format });
+	}
+	/** Sets the displayed tire pressure unit. */
+	async set_tire_pressure_unit(unit) {
+		return this._custom_command("set_tire_pressure_unit", { unit });
+	}
+	/** Sets the displayed energy unit (percentage or distance). */
+	async set_energy_display_format(format) {
+		return this._custom_command("set_energy_display_format", { format });
+	}
+	/** Activates or deactivates parental controls with a PIN. */
+	async parental_controls(activate, pin) {
+		return this._custom_command("parental_controls", {
+			activate,
+			pin
+		});
+	}
+	/** Clears the parental controls PIN. */
+	async parental_controls_clear_pin(pin) {
+		return this._custom_command("parental_controls_clear_pin", { pin });
+	}
+	/** Clears the parental controls PIN as admin (fleet manager or owner). */
+	async parental_controls_clear_pin_admin() {
+		return this._custom_command("parental_controls_clear_pin_admin");
+	}
+	/**
+	* Enables or disables a parental controls setting.
+	* @param setting 1 speed limit, 2 acceleration, 3 safety features, 4 curfew.
+	* @param enable
+	*/
+	async parental_controls_enable_setting(setting, enable) {
+		return this._custom_command("parental_controls_enable_setting", {
+			setting,
+			enable
+		});
+	}
+	/** Sets the parental controls speed limit. */
+	async parental_controls_set_speed_limit(limit_mph) {
+		return this._custom_command("parental_controls_set_speed_limit", { limit_mph });
+	}
+	/**
+	* Navigates to coordinates with a named destination. Named to match the signed sibling for router failover.
+	* @param lat
+	* @param lon
+	* @param destination
+	* @param order Sent as given: on tesla-protocol 6, `RemoteNavTripOrder_E` is 0 replace, 1 prepend, 2 append.
+	*/
+	async navigation_gps_destination_request(lat, lon, destination, order) {
+		return this._custom_command("navigation_gps_destination", {
+			lat,
+			lon,
+			destination,
+			order
+		});
+	}
+	/** Auto-secures the vehicle: locks it, closes windows, and so on. */
+	async auto_secure_vehicle() {
+		return this._custom_command("auto_secure_vehicle");
+	}
+	/** Cancels a State of Health test. */
+	async cancel_soh_test() {
+		return this._custom_command("cancel_soh_test");
+	}
+	/** Returns the charging sites near the vehicle's current location. */
+	async get_nearby_charging_sites(count, radius, detail) {
+		return this._custom_command("get_nearby_charging_sites", {
+			count,
+			radius,
+			detail
+		});
+	}
+	/** Gets the current time-of-use rate tariff schedule. */
+	async get_rate_tariff() {
+		return this._custom_command("get_rate_tariff");
+	}
+	/**
+	* Triggers a time-of-use rate tariff update, with no schedule payload.
+	* Deliberately not named `set_rate_tariff`: the signed sibling takes a
+	* required schedule, which a router failing over here would silently drop.
+	*/
+	async trigger_rate_tariff_update() {
+		return this._custom_command("set_rate_tariff");
+	}
+	/**
+	* Gets a snapshot of cached vehicle telemetry.
+	* @param topics Topics to include.
+	* @param cursor Return only what changed since this cursor.
+	*/
+	async telemetry(topics, cursor) {
+		return this._request("GET", `api/1/vehicles/${this.vin}/telemetry`, {
+			topics: joinTopics(topics),
+			cursor
+		});
+	}
+	/** Creates a cursor-aware reader of this vehicle's cached telemetry. */
+	create_telemetry_tracker(topics) {
+		return new TeslemetryVehicleTelemetry(this, topics);
+	}
+};
+function joinTopics(topics) {
+	return Array.isArray(topics) ? topics.join(";") : topics;
+}
+/** Python truthiness, which an update's fields are tested by: an empty object or list counts as absent. */
+function hasContent(value) {
+	return value !== null && typeof value === "object" ? Object.keys(value).length > 0 : !!value;
+}
+/** A cursor-aware vehicle telemetry reader, keeping a snapshot merged from each update. */
+var TeslemetryVehicleTelemetry = class {
+	/** The cursor the next `update()` sends. */
+	cursor = 0;
+	/** Everything received so far. `data` merges field by field; other topics are replaced whole. */
+	snapshot = {};
+	_parent;
+	_topics;
+	constructor(parent, topics) {
+		this._parent = parent;
+		this._topics = joinTopics(topics);
+	}
+	/**
+	* Get the changes since the last update, and merge them into `snapshot`.
+	* @returns The update's `response`.
+	* @throws InvalidResponse when the update has an empty `response`, or no `cursor`.
+	*/
+	async update() {
+		const response = (await this._parent.telemetry(this._topics, this.cursor))?.response;
+		if (!hasContent(response)) throw new require_exceptions.InvalidResponse("No response from telemetry");
+		if (typeof response !== "object" || !("cursor" in response)) throw new require_exceptions.InvalidResponse("Telemetry response did not contain a cursor");
+		this.cursor = response.cursor;
+		if (hasContent(response.state)) this.snapshot.state = response.state;
+		if (hasContent(response.data)) this.snapshot.data = {
+			...this.snapshot.data,
+			...response.data
+		};
+		for (const topic of [
+			"connectivity",
+			"alerts",
+			"errors",
+			"vehicle_data"
+		]) if (hasContent(response[topic])) this.snapshot[topic] = response[topic];
+		return response;
+	}
+};
+/** Creates `TeslemetryVehicle`s. Teslemetry cannot use the Fleet API directly, so `create` is the only factory. */
+var TeslemetryVehicles = class extends require_vehicle.default {
+	/** Class `create` instantiates; a subclass overrides it to supply its own vehicle type. */
+	static Vehicle = TeslemetryVehicle;
+	createFleet = void 0;
+	createSigned = void 0;
+	specific = void 0;
+	specificSigned = void 0;
+	/** Creates a vehicle, and records it by VIN. */
+	create(vin) {
+		const vehicle = new this.constructor.Vehicle(this, vin);
+		this.byVin.set(vin, vehicle);
+		return vehicle;
+	}
+};
+exports.TeslemetryVehicle = TeslemetryVehicle;
+exports.TeslemetryVehicleTelemetry = TeslemetryVehicleTelemetry;
+exports.TeslemetryVehicles = TeslemetryVehicles;