tesla-fleet-api 0.3.0 → 0.5.0

package/dist/tariff.mjs

@@ -0,0 +1,317 @@
+import { InvalidResponse } from "./exceptions.mjs";
+// src/tariff.ts
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Extract the `tariff_content_v2` object from a raw API response.
+*
+* Accepts the `site_info` read envelope (`{ response: { tariff_content_v2 } }`), the
+* `time_of_use_settings` write envelope (`{ tou_settings: { tariff_content_v2 } }`), or the bare
+* `tariff_content_v2` object itself. Throws {@link InvalidResponse} for a null body, an
+* unrecognized envelope, or an extracted object without the minimal Tariff V2 shape (`seasons`
+* and `energy_charges`) - checked identically on every path, since a malformed body (including an
+* empty `{}` nested under a recognized envelope) is not the same as "no tariff configured".
+*/
+function unwrapTariffV2(response) {
+	if (response == null) throw new InvalidResponse("tariff response body was null");
+	if (!isObject(response)) throw new InvalidResponse(String(response));
+	let candidate;
+	if ("tariff_content_v2" in response) candidate = response.tariff_content_v2;
+	else if ("response" in response || "tou_settings" in response) {
+		const inner = "response" in response ? response.response : response.tou_settings;
+		candidate = isObject(inner) ? inner.tariff_content_v2 : void 0;
+	} else candidate = response;
+	if (isObject(candidate) && "seasons" in candidate && "energy_charges" in candidate) return candidate;
+	throw new InvalidResponse(response);
+}
+const MINUTES_PER_DAY = 1440;
+function formatParts(date, timeZone) {
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hourCycle: "h23"
+	}).formatToParts(date);
+	const out = {};
+	for (const p of parts) out[p.type] = Number(p.value);
+	return out;
+}
+/** Tesla weekday (Mon=0..Sun=6) for a calendar date, via JS Date.getUTCDay() (Sun=0..Sat=6). */
+function dowFromDate(year, month, day) {
+	return (new Date(Date.UTC(year, month - 1, day)).getUTCDay() + 6) % 7;
+}
+function getWallClock(now, timeZone) {
+	const { year, month, day, hour, minute } = formatParts(now, timeZone);
+	return {
+		year,
+		month,
+		day,
+		dow: dowFromDate(year, month, day),
+		minuteOfDay: hour * 60 + minute
+	};
+}
+/**
+* Converts a target site-local wall-clock (year/month/day/hour/minute in `timeZone`) to the UTC
+* instant it represents. Iterates because the zone's UTC offset at the target instant is itself
+* what we're solving for (DST) - 3 rounds converges for any real-world offset change.
+*/
+function wallClockToUtcMillis(year, month, day, hour, minute, timeZone) {
+	const target = Date.UTC(year, month - 1, day, hour, minute);
+	let guess = target;
+	for (let i = 0; i < 3; i++) {
+		const p = formatParts(new Date(guess), timeZone);
+		const next = target - (Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second) - guess);
+		if (next === guess) break;
+		guess = next;
+	}
+	return guess;
+}
+/**
+* Adds `deltaMinutes` of wall-clock time (not elapsed real time) to a wall-clock reading, staying
+* in pure calendar arithmetic throughout - no `timeZone`/`Intl` round trip, so this is safe to use
+* for "what day/weekday is N minutes from now" even across a DST transition, where a real-time-ms
+* shift and a wall-clock-minutes shift land on different calendar days.
+*/
+function wallClockAt(wallClock, deltaMinutes) {
+	const naive = new Date(Date.UTC(wallClock.year, wallClock.month - 1, wallClock.day, 0, wallClock.minuteOfDay + deltaMinutes));
+	const year = naive.getUTCFullYear();
+	const month = naive.getUTCMonth() + 1;
+	const day = naive.getUTCDate();
+	const minuteOfDay = naive.getUTCHours() * 60 + naive.getUTCMinutes();
+	return {
+		year,
+		month,
+		day,
+		dow: dowFromDate(year, month, day),
+		minuteOfDay
+	};
+}
+function dowInRange(d, fromDow, toDow) {
+	return fromDow <= toDow ? d >= fromDow && d <= toDow : d >= fromDow || d <= toDow;
+}
+function seasonContains(season, month, day) {
+	if (!season?.tou_periods) return false;
+	const fromMonth = season.fromMonth ?? 1;
+	const fromDay = season.fromDay ?? 1;
+	const toMonth = season.toMonth ?? 12;
+	const toDay = season.toDay ?? 31;
+	const from = fromMonth * 100 + fromDay;
+	const to = toMonth * 100 + toDay;
+	const cur = month * 100 + day;
+	return from <= to ? cur >= from && cur <= to : cur >= from || cur <= to;
+}
+function findSeason(seasons, month, day) {
+	if (!seasons) return null;
+	for (const [name, season] of Object.entries(seasons)) if (seasonContains(season, month, day)) return {
+		name,
+		season
+	};
+	return null;
+}
+/**
+* Expands a season's `tou_periods` into the windows active on one specific calendar day (given
+* as a Tesla weekday, Mon=0..Sun=6). A period whose `fromDayOfWeek..toDayOfWeek` includes `dow`
+* contributes its own window (clamped to this day, `endMin` capped at 1440 if it crosses
+* midnight); a period that crosses midnight and includes *yesterday* also contributes its
+* early-morning continuation here, `trueStartMin` carrying its real (pre-midnight) start so a
+* currently-active continuation can still report an accurate `currentStart`.
+*/
+function dayPeriods(touPeriods, dow) {
+	const segments = [];
+	const prevDow = (dow + 6) % 7;
+	for (const [periodName, def] of Object.entries(touPeriods)) for (const window of def.periods ?? []) {
+		const fromDow = window.fromDayOfWeek ?? 0;
+		const toDow = window.toDayOfWeek ?? 6;
+		const fromMin = (window.fromHour ?? 0) * 60 + (window.fromMinute ?? 0);
+		const toMin = (window.toHour ?? 0) * 60 + (window.toMinute ?? 0);
+		const crossesMidnight = toMin <= fromMin;
+		if (dowInRange(dow, fromDow, toDow)) {
+			const endMin = crossesMidnight ? MINUTES_PER_DAY : toMin;
+			if (endMin > fromMin) segments.push({
+				periodName,
+				startMin: fromMin,
+				endMin,
+				trueStartMin: fromMin
+			});
+		}
+		if (crossesMidnight && toMin > 0 && dowInRange(prevDow, fromDow, toDow)) segments.push({
+			periodName,
+			startMin: 0,
+			endMin: toMin,
+			trueStartMin: fromMin - MINUTES_PER_DAY
+		});
+	}
+	return segments;
+}
+function lookupPrice(charges, seasonName, periodName) {
+	if (!charges) return null;
+	const seasonRates = charges[seasonName]?.rates ?? charges["ALL"]?.rates;
+	if (!seasonRates) return null;
+	const value = Object.prototype.hasOwnProperty.call(seasonRates, periodName) ? seasonRates[periodName] : seasonRates["ALL"];
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+const EMPTY_RATE = {
+	price: null,
+	periodName: null,
+	seasonName: null
+};
+/**
+* Resolves one grid's (buy's, or sell's) state at `wallClock`: the active period if any, and the
+* next boundary regardless of whether a period is currently active - a sparse tariff's gap still
+* has a "next change" (the gap's own end) and a "since" (the gap's own start), just like an active
+* period does (its own end and start).
+*/
+function scheduleAt(seasons, wallClock) {
+	const matched = findSeason(seasons, wallClock.month, wallClock.day);
+	if (!matched) return null;
+	const todaySegs = dayPeriods(matched.season.tou_periods, wallClock.dow);
+	const current = todaySegs.find((s) => s.startMin <= wallClock.minuteOfDay && wallClock.minuteOfDay < s.endMin) ?? null;
+	const laterTodayStarts = todaySegs.filter((s) => s.startMin > wallClock.minuteOfDay).map((s) => s.startMin);
+	let nextMin = current ? current.endMin : null;
+	if (laterTodayStarts.length > 0) nextMin = nextMin === null ? Math.min(...laterTodayStarts) : Math.min(nextMin, Math.min(...laterTodayStarts));
+	else if (nextMin === null || nextMin >= MINUTES_PER_DAY) {
+		const tomorrowWallClock = wallClockAt(wallClock, MINUTES_PER_DAY - wallClock.minuteOfDay);
+		const tomorrowMatched = findSeason(seasons, tomorrowWallClock.month, tomorrowWallClock.day);
+		const tomorrowSegs = tomorrowMatched ? dayPeriods(tomorrowMatched.season.tou_periods, tomorrowWallClock.dow) : [];
+		const continuation = current && tomorrowMatched?.name === matched.name ? tomorrowSegs.find((s) => s.startMin === 0 && s.periodName === current.periodName) : void 0;
+		if (continuation) nextMin = MINUTES_PER_DAY + continuation.endMin;
+		else if (tomorrowSegs.length > 0) {
+			const tomorrowFirst = MINUTES_PER_DAY + Math.min(...tomorrowSegs.map((s) => s.startMin));
+			nextMin = nextMin === null ? tomorrowFirst : Math.min(nextMin, tomorrowFirst);
+		}
+	}
+	let sinceMin;
+	if (current) sinceMin = current.trueStartMin;
+	else {
+		const earlierTodayEnds = todaySegs.filter((s) => s.endMin <= wallClock.minuteOfDay).map((s) => s.endMin);
+		if (earlierTodayEnds.length > 0) sinceMin = Math.max(...earlierTodayEnds);
+		else {
+			const yesterdayWallClock = wallClockAt(wallClock, -1440);
+			const yesterdayMatched = findSeason(seasons, yesterdayWallClock.month, yesterdayWallClock.day);
+			const yesterdaySegs = yesterdayMatched ? dayPeriods(yesterdayMatched.season.tou_periods, yesterdayWallClock.dow) : [];
+			sinceMin = yesterdaySegs.length > 0 ? Math.max(...yesterdaySegs.map((s) => s.endMin)) - MINUTES_PER_DAY : null;
+		}
+	}
+	return {
+		seasonName: matched.name,
+		current,
+		nextChangeGM: nextMin === null ? null : nextMin - wallClock.minuteOfDay,
+		sinceGM: sinceMin === null ? null : sinceMin - wallClock.minuteOfDay
+	};
+}
+/** Walks one calendar day at a time across the horizon, re-resolving the season fresh on each day (via pure wall-clock arithmetic, not elapsed-ms/DST-sensitive arithmetic) so a horizon crossing a season boundary re-prices and re-labels correctly. */
+function collectSegments(seasons, wallClock, horizonMinutes) {
+	const segments = [];
+	let dayStartGM = -wallClock.minuteOfDay;
+	while (dayStartGM < horizonMinutes) {
+		const dayWallClock = wallClockAt(wallClock, dayStartGM);
+		const matched = findSeason(seasons, dayWallClock.month, dayWallClock.day);
+		if (matched) for (const seg of dayPeriods(matched.season.tou_periods, dayWallClock.dow)) {
+			const startGM = dayStartGM + seg.startMin;
+			const endGM = dayStartGM + seg.endMin;
+			if (endGM > 0 && startGM < horizonMinutes) segments.push({
+				startGM,
+				endGM,
+				periodName: seg.periodName,
+				seasonName: matched.name
+			});
+		}
+		dayStartGM += MINUTES_PER_DAY;
+	}
+	segments.sort((a, b) => a.startGM - b.startGM);
+	const merged = [];
+	for (const seg of segments) {
+		const last = merged[merged.length - 1];
+		if (last && last.endGM === seg.startGM && last.periodName === seg.periodName && last.seasonName === seg.seasonName) last.endGM = seg.endGM;
+		else merged.push({ ...seg });
+	}
+	return merged;
+}
+function buildUpcoming(buySeasons, buyCharges, sellSeasons, sellCharges, hasSell, wallClock, horizonMinutes, toDate) {
+	const buySegs = collectSegments(buySeasons, wallClock, horizonMinutes);
+	const sellSegs = hasSell ? collectSegments(sellSeasons, wallClock, horizonMinutes) : [];
+	const boundaries = /* @__PURE__ */ new Set([0, horizonMinutes]);
+	const addBoundary = (gm) => {
+		if (gm > 0 && gm < horizonMinutes) boundaries.add(gm);
+	};
+	for (const s of buySegs) {
+		addBoundary(s.startGM);
+		addBoundary(s.endGM);
+	}
+	for (const s of sellSegs) {
+		addBoundary(s.startGM);
+		addBoundary(s.endGM);
+	}
+	const sorted = [...boundaries].sort((a, b) => a - b);
+	const periods = [];
+	for (let i = 0; i < sorted.length - 1; i++) {
+		const segStart = sorted[i];
+		const segEnd = sorted[i + 1];
+		if (segStart === segEnd) continue;
+		const buyAt = buySegs.find((s) => s.startGM <= segStart && segStart < s.endGM);
+		const sellAt = sellSegs.find((s) => s.startGM <= segStart && segStart < s.endGM);
+		periods.push({
+			start: toDate(segStart),
+			end: toDate(segEnd),
+			buy: buyAt ? {
+				price: lookupPrice(buyCharges, buyAt.seasonName, buyAt.periodName),
+				periodName: buyAt.periodName,
+				seasonName: buyAt.seasonName
+			} : EMPTY_RATE,
+			sell: sellAt ? {
+				price: lookupPrice(sellCharges, sellAt.seasonName, sellAt.periodName),
+				periodName: sellAt.periodName,
+				seasonName: sellAt.seasonName
+			} : EMPTY_RATE
+		});
+	}
+	return periods;
+}
+/**
+* Resolves the current buy/sell time-of-use rate for a Tariff V2 object at a given instant.
+* `tariff` carries no timezone; the caller must supply the site's IANA zone (e.g. from
+* `site_info.installation_time_zone`) so wall-clock period boundaries match correctly.
+*/
+function getTariffPeriods(tariff, now, opts) {
+	if (!tariff?.seasons || !tariff?.energy_charges) return null;
+	if (!opts?.timeZone) throw new Error("getTariffPeriods requires opts.timeZone");
+	const timeZone = opts.timeZone;
+	const wallClock = getWallClock(now, timeZone);
+	const buySchedule = scheduleAt(tariff.seasons, wallClock);
+	if (!buySchedule?.current) return null;
+	const sellSeasons = tariff.sell_tariff?.seasons ?? tariff.seasons;
+	const sellSchedule = tariff.sell_tariff ? scheduleAt(sellSeasons, wallClock) : null;
+	const buyRate = {
+		price: lookupPrice(tariff.energy_charges, buySchedule.seasonName, buySchedule.current.periodName),
+		periodName: buySchedule.current.periodName,
+		seasonName: buySchedule.seasonName
+	};
+	const sellRate = sellSchedule?.current ? {
+		price: lookupPrice(tariff.sell_tariff.energy_charges, sellSchedule.seasonName, sellSchedule.current.periodName),
+		periodName: sellSchedule.current.periodName,
+		seasonName: sellSchedule.seasonName
+	} : EMPTY_RATE;
+	const toDate = (gm) => {
+		const target = wallClockAt(wallClock, gm);
+		const hour = Math.floor(target.minuteOfDay / 60);
+		const minute = target.minuteOfDay % 60;
+		return new Date(wallClockToUtcMillis(target.year, target.month, target.day, hour, minute, timeZone));
+	};
+	const nextChangeGM = sellSchedule?.nextChangeGM != null ? Math.min(buySchedule.nextChangeGM, sellSchedule.nextChangeGM) : buySchedule.nextChangeGM;
+	const resolution = {
+		buy: buyRate,
+		sell: sellRate,
+		currentStart: toDate(sellSchedule?.sinceGM != null ? Math.max(buySchedule.sinceGM, sellSchedule.sinceGM) : buySchedule.sinceGM),
+		nextChange: toDate(nextChangeGM),
+		currency: typeof tariff.currency === "string" ? tariff.currency : null,
+		upcoming: null
+	};
+	if (opts.horizonHours) resolution.upcoming = buildUpcoming(tariff.seasons, tariff.energy_charges, sellSeasons, tariff.sell_tariff?.energy_charges, !!tariff.sell_tariff, wallClock, opts.horizonHours * 60, toDate);
+	return resolution;
+}
+export { getTariffPeriods, unwrapTariffV2 };

package/dist/teslafleetapi.cjs

@@ -0,0 +1,326 @@
+const require_charging = require("./charging.cjs");
+const require_energy = require("./energy.cjs");
+const require_partner = require("./partner.cjs");
+const require_user = require("./user.cjs");
+const require_vehicle = require("./vehicle.cjs");
+const require_const = require("./const.cjs");
+const require_exceptions = require("./exceptions.cjs");
+const require_log = require("./log.cjs");
+const require_crypto = require("./signing/crypto.cjs");
+const require_keys = require("./signing/keys.cjs");
+let node_crypto = require("node:crypto");
+// src/teslafleetapi.ts
+var TeslaFleetApi = class {
+	/** Class backing `vehicles`; a subclass (e.g. `Teslemetry`) overrides it instead of its constructor. */
+	static Vehicles = require_vehicle.default;
+	/** Class backing `energySites`; a subclass overrides it instead of its constructor. */
+	static EnergySites = require_energy.default;
+	server = null;
+	region = null;
+	accessToken;
+	charging;
+	energySites;
+	partner;
+	user;
+	vehicles;
+	/** Log to `console.debug` when no `logger` is set. */
+	debug = false;
+	logger;
+	/** Abort a request (including reading its body) after this many milliseconds; `null` waits indefinitely. */
+	timeout;
+	/** Transport identity for debug logging; Teslemetry and Tessie override this. */
+	_transport_name = "fleet";
+	#fetch;
+	#privateKey = null;
+	#rsaPrivateKey = null;
+	constructor(options) {
+		this.debug = !!options.debug;
+		this.logger = options.logger ?? null;
+		this.#fetch = options.fetch ?? null;
+		this.timeout = options.timeout ?? null;
+		this.accessToken = options.accessToken ?? null;
+		if (options.server) this.server = options.server;
+		else if (options.region && require_const.is_valid_region(options.region)) {
+			this.region = options.region;
+			this.server = require_const.SERVERS[options.region];
+		} else throw new Error("Either server or region must be provided.");
+		this._log(`Using server ${this.server}`);
+		const factories = this.constructor;
+		if (options.chargingScope !== false) this.charging = new require_charging.default(this);
+		if (options.energyScope !== false) this.energySites = new factories.EnergySites(this);
+		if (options.userScope !== false) this.user = new require_user.default(this);
+		if (options.partnerScope !== false) this.partner = new require_partner.default(this);
+		if (options.vehicleScope !== false) this.vehicles = new factories.Vehicles(this);
+	}
+	/** Write a debug line to `logger`, or to `console.debug` when `debug` is set. */
+	_log(message) {
+		if (this.logger) this.logger.debug(message);
+		else if (this.debug) console.debug(message);
+	}
+	/** The injected `fetch`, resolved per call so the global is read late. */
+	_fetch(input, init) {
+		return (this.#fetch ?? fetch)(input, init);
+	}
+	/**
+	* Find the server for this user's region by asking each Tesla server in
+	* turn, skipping any that answers `InvalidRegion`.
+	* @returns The region, e.g. `"na"`.
+	*/
+	async find_server() {
+		for (const server of Object.values(require_const.SERVERS)) {
+			this.server = server;
+			try {
+				const { response } = await this._request("GET", "api/1/users/region");
+				if (response) {
+					this.server = response.fleet_api_base_url;
+					if (require_const.is_valid_region(response.region)) this.region = response.region;
+					this._log(`Using server ${this.server}`);
+					return response.region;
+				}
+			} catch (error) {
+				if (error instanceof require_exceptions.InvalidRegion) continue;
+				throw error;
+			}
+		}
+		throw new require_exceptions.LibraryError("Could not find a valid Tesla API server.");
+	}
+	/**
+	* The current access token, calling it first if it is a function.
+	* @throws MissingToken when there is no token.
+	*/
+	async access_token() {
+		const token = typeof this.accessToken === "function" ? await this.accessToken() : this.accessToken;
+		if (token == null) throw new require_exceptions.MissingToken();
+		return token;
+	}
+	/**
+	* Turn a response into its decoded JSON body, throwing the matching
+	* `TeslaFleetError` for an error status and `ResponseError` for a
+	* successful response whose body is not JSON.
+	*/
+	async _response(resp) {
+		await require_exceptions.raise_for_status(resp);
+		const text = await resp.text();
+		try {
+			return JSON.parse(text);
+		} catch {
+			this._log(`Response type is: ${resp.headers.get("content-type")}`);
+			throw new require_exceptions.ResponseError(text, resp.status);
+		}
+	}
+	/**
+	* Make a request to the Tesla Fleet API.
+	* @param method
+	* @param path
+	* @param params Query parameters; null and undefined values are dropped.
+	* @param json Body; null and undefined values are dropped, and a GET sends none.
+	* @returns The decoded JSON body.
+	* @throws `MissingToken` when there is no access token, a `TeslaFleetError`
+	* subclass for an error status, or `TeslaFleetConnectionError` (with the
+	* original error as `cause`) when the request could not complete or timed out.
+	*/
+	async _request(method, path, params = null, json = null) {
+		const command = path.slice(path.lastIndexOf("/") + 1);
+		let data;
+		try {
+			if (!this.server) throw new Error("Server was not set at init. Call find_server() first.");
+			if (method === "GET") json = null;
+			const headers = {
+				Authorization: `Bearer ${await this.access_token()}`,
+				"X-Library": `node tesla_fleet_api 0.5.0`
+			};
+			const query = new URLSearchParams();
+			if (params) {
+				for (const [key, value] of Object.entries(params)) if (value != null) query.append(key, typeof value === "boolean" ? value ? "true" : "false" : String(value));
+				this._log(`Parameters: ${require_log.redactedQuery(query)}`);
+			}
+			let body = null;
+			if (json) {
+				json = Object.fromEntries(Object.entries(json).filter(([_, v]) => v != null));
+				body = JSON.stringify(json);
+				this._log(`Body: ${require_log.redactedJson(json)}`);
+				headers["Content-Type"] = "application/json";
+			}
+			const search = query.size ? `?${query.toString()}` : "";
+			const url = `${this.server}/${path}${search}`;
+			try {
+				const resp = await this._fetch(url, {
+					method,
+					headers,
+					body,
+					signal: this.timeout != null ? AbortSignal.timeout(this.timeout) : null
+				});
+				this._log(`Status ${resp.status} from ${this.server}/${path}`);
+				for (const [header, label] of [
+					["x-txid", "Response TXID"],
+					["RateLimit-Reset", "Rate limit reset"],
+					["Retry-After", "Retry after"]
+				]) if (resp.headers.has(header)) this._log(`${label}: ${resp.headers.get(header)}`);
+				data = await this._response(resp);
+			} catch (error) {
+				if (error instanceof require_exceptions.TeslaFleetError) throw error;
+				throw new require_exceptions.TeslaFleetConnectionError(null, null, { cause: error });
+			}
+			this._log(`Response JSON: ${require_log.redactedJson(data)}`);
+		} catch (error) {
+			require_log.logRequestError((m) => this._log(m), command, this._transport_name, error);
+			throw error;
+		}
+		require_log.logRequestResult((m) => this._log(m), command, this._transport_name, data);
+		return data;
+	}
+	/**
+	* Returns `"ok"` if the API is operating normally. Sends no headers.
+	*/
+	async status() {
+		if (!this.server) throw new Error("Server was not set at init. Call find_server() first.");
+		return (await this._fetch(`${this.server}/status`)).text();
+	}
+	/**
+	* Generate a partner token using client credentials authentication, and use
+	* it as the access token for later requests.
+	* @param client_id Partner application client ID.
+	* @param client_secret Partner application client secret.
+	* @param scopes Scopes to request.
+	* @returns The token response, including `access_token`.
+	*/
+	async partner_login(client_id, client_secret, scopes = [require_const.Scope.OPENID]) {
+		if (!this.server) throw new Error("Server was not set at init. Call find_server() first.");
+		const resp = await this._fetch(require_const.TOKEN_URLS[this.region ?? "na"], {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams({
+				grant_type: "client_credentials",
+				client_id,
+				client_secret,
+				audience: this.server,
+				scope: scopes.join(" ")
+			})
+		});
+		await require_exceptions.raise_for_status(resp);
+		const tokenData = await resp.json();
+		this.accessToken = tokenData.access_token;
+		return tokenData;
+	}
+	/**
+	* Returns products mapped to user.
+	* @returns An array of products including both vehicles and energy sites.
+	*/
+	async products() {
+		return this._request("GET", "api/1/products");
+	}
+	/**
+	* Return Tesla products separated into vehicles and energy_sites
+	* @returns A dictionary of vehicles and energy sites, each with an array of those products
+	*/
+	async products_by_type() {
+		return this.products().then(({ response: products }) => ({
+			vehicles: products.filter((product) => "vin" in product),
+			energy_sites: products.filter((product) => "energy_site_id" in product)
+		}));
+	}
+	/**
+	* Get or create the P-256 key that signs vehicle commands, and keep it as
+	* `private_key`. The file is an unencrypted PEM that Python's
+	* `get_private_key` shares, created at mode 0600. If another process wins the
+	* create race, its file is read instead.
+	* @param path Key file.
+	* @returns The raw 32-byte key `Commands` takes.
+	* @throws PrivateKeyError for an existing file that cannot be used.
+	*/
+	async get_private_key(path = "private_key.pem") {
+		const key = await require_keys.ecPrivateKeyFile(path);
+		this.private_key = key;
+		return key;
+	}
+	/** The raw 32-byte P-256 key, which `createSigned` falls back to. */
+	get private_key() {
+		return this.#privateKey;
+	}
+	set private_key(key) {
+		this.#privateKey = key;
+	}
+	/** Whether the private key has been set. */
+	get has_private_key() {
+		return this.#privateKey != null;
+	}
+	/** The public key in PEM format. */
+	get public_pem() {
+		return this.#ecPublicKey("Private key is not set").export({
+			type: "spki",
+			format: "pem"
+		});
+	}
+	/** The public key's uncompressed point, in hex. */
+	get public_uncompressed_point() {
+		if (this.#privateKey == null) throw new require_exceptions.LibraryError("Private key is not set");
+		return require_crypto.publicKeyFor(this.#privateKey).toString("hex");
+	}
+	/**
+	* The EC public key in DER SubjectPublicKeyInfo form, as an energy gateway
+	* expects when registering an ECC authorized client. It rejects the raw point
+	* that vehicles use.
+	*/
+	get ec_public_der_spki() {
+		return this.#ecPublicKey("EC private key is not set").export({
+			type: "spki",
+			format: "der"
+		});
+	}
+	/** `ec_public_der_spki`, base64-encoded. */
+	get ec_public_der_spki_b64() {
+		return this.ec_public_der_spki.toString("base64");
+	}
+	#ecPublicKey(unsetMessage) {
+		if (this.#privateKey == null) throw new require_exceptions.LibraryError(unsetMessage);
+		return require_keys.ecPublicKey(this.#privateKey);
+	}
+	/**
+	* Get or create the RSA key for energy gateway client registration, and keep
+	* it as `rsa_private_key`. The file is an unencrypted PEM that Python's
+	* `get_rsa_private_key` shares, created at mode 0600. If another process wins
+	* the create race, its file is read instead. Generation runs off the event loop.
+	* @param path Key file.
+	* @param key_size Modulus length in bits for a new key; 4096 is what Powerwall v1r expects.
+	* @throws PrivateKeyError for an existing file that cannot be used.
+	*/
+	async get_rsa_private_key(path = "tedapi_rsa_private.pem", key_size = 4096) {
+		const key = await require_keys.rsaPrivateKeyFile(path, key_size);
+		this.rsa_private_key = key;
+		return key;
+	}
+	/** The RSA key for energy gateway client registration. */
+	get rsa_private_key() {
+		return this.#rsaPrivateKey;
+	}
+	set rsa_private_key(key) {
+		this.#rsaPrivateKey = key;
+	}
+	/** Whether the RSA private key has been set. */
+	get has_rsa_private_key() {
+		return this.#rsaPrivateKey != null;
+	}
+	/**
+	* The RSA public key in DER PKCS#1 form, as an energy gateway expects when
+	* registering an authorized client.
+	*/
+	get rsa_public_der_pkcs1() {
+		return require_keys.rsaPublicDerPkcs1(this.#rsaKey());
+	}
+	/** `rsa_public_der_pkcs1`, base64-encoded. */
+	get rsa_public_der_pkcs1_b64() {
+		return this.rsa_public_der_pkcs1.toString("base64");
+	}
+	/** The RSA public key in PEM (SubjectPublicKeyInfo) format. */
+	get rsa_public_pem() {
+		return (0, node_crypto.createPublicKey)(this.#rsaKey()).export({
+			type: "spki",
+			format: "pem"
+		});
+	}
+	#rsaKey() {
+		if (this.#rsaPrivateKey == null) throw new require_exceptions.LibraryError("RSA private key is not set");
+		return this.#rsaPrivateKey;
+	}
+};
+exports.default = TeslaFleetApi;