tesla-fleet-api 0.2.2 → 0.4.0

package/dist/{tariff.d.ts → tariff.d.cts}

@@ -1,22 +1,22 @@
-import { TariffContentV2 } from "./types/site_info.js";
+import { TariffContentV2 } from "./types/site_info.cjs";
 export interface TariffRate {
-    price: number | null;
-    periodName: string | null;
-    seasonName: string | null;
+  price: number | null;
+  periodName: string | null;
+  seasonName: string | null;
 }
 export interface TariffPeriod {
-    start: Date;
-    end: Date;
-    buy: TariffRate;
-    sell: TariffRate;
+  start: Date;
+  end: Date;
+  buy: TariffRate;
+  sell: TariffRate;
 }
 export interface TariffResolution {
-    buy: TariffRate;
-    sell: TariffRate;
-    currentStart: Date;
-    nextChange: Date;
-    currency: string | null;
-    upcoming: TariffPeriod[] | null;
+  buy: TariffRate;
+  sell: TariffRate;
+  currentStart: Date;
+  nextChange: Date;
+  currency: string | null;
+  upcoming: TariffPeriod[] | null;
 }
 /**
  * Resolves the current buy/sell time-of-use rate for a Tariff V2 object at a given instant.
@@ -24,6 +24,6 @@ export interface TariffResolution {
  * `site_info.installation_time_zone`) so wall-clock period boundaries match correctly.
  */
 export declare function getTariffPeriods(tariff: TariffContentV2, now: Date, opts?: {
-    timeZone: string;
-    horizonHours?: number;
-}): TariffResolution | null;
+  timeZone: string;
+  horizonHours?: number;
+}): TariffResolution | null;

package/dist/tariff.d.mts

@@ -0,0 +1,29 @@
+import { TariffContentV2 } from "./types/site_info.mjs";
+export interface TariffRate {
+  price: number | null;
+  periodName: string | null;
+  seasonName: string | null;
+}
+export interface TariffPeriod {
+  start: Date;
+  end: Date;
+  buy: TariffRate;
+  sell: TariffRate;
+}
+export interface TariffResolution {
+  buy: TariffRate;
+  sell: TariffRate;
+  currentStart: Date;
+  nextChange: Date;
+  currency: string | null;
+  upcoming: TariffPeriod[] | null;
+}
+/**
+ * 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.
+ */
+export declare function getTariffPeriods(tariff: TariffContentV2, now: Date, opts?: {
+  timeZone: string;
+  horizonHours?: number;
+}): TariffResolution | null;

package/dist/tariff.mjs

@@ -0,0 +1,291 @@
+// src/tariff.ts
+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 };

package/dist/teslafleetapi.cjs

@@ -0,0 +1,125 @@
+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");
+// src/teslafleetapi.ts
+var TeslaFleetApi = class {
+	server = null;
+	accessToken;
+	charging;
+	energy;
+	partner;
+	user;
+	vehicle;
+	debug = false;
+	/** Abort a request (including reading its body) after this many milliseconds; `null` waits indefinitely. */
+	timeout;
+	constructor(options) {
+		this.debug = !!options.debug;
+		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.server = require_const.SERVERS[options.region];
+		else throw new Error("Either server or region must be provided.");
+		this.debug && console.debug(`Using server ${this.server}`);
+		if (options.chargingScope !== false) this.charging = new require_charging.default(this);
+		if (options.energyScope !== false) this.energy = new require_energy.default(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.vehicle = new require_vehicle.default(this);
+	}
+	/**
+	* 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 {
+			throw new require_exceptions.ResponseError(text, resp.status);
+		}
+	}
+	/**
+	* Make a request to the Tesla Fleet API.
+	* @param method
+	* @param path
+	* @param params
+	* @param json
+	* @returns The decoded JSON body.
+	* @throws 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) {
+		if (!this.server) throw new Error("Server was not set at init. Call findServer() first.");
+		if (method === "GET" && json !== null) throw new Error("GET requests cannot have a body.");
+		this.debug && console.debug(`Sending request to ${path}`);
+		if (params) {
+			params = Object.fromEntries(Object.entries(params).filter(([_, v]) => v != null));
+			this.debug && console.debug(`Parameters: ${JSON.stringify(params)}`);
+		}
+		if (json) {
+			json = Object.fromEntries(Object.entries(json).filter(([_, v]) => v != null));
+			this.debug && console.debug(`Body: ${JSON.stringify(json)}`);
+		}
+		const headers = {
+			Authorization: `Bearer ${this.accessToken}`,
+			"Content-Type": "application/json",
+			"X-Library": `node tesla_fleet_api`
+		};
+		const query = params ? "?" + new URLSearchParams(params).toString() : "";
+		try {
+			const resp = await fetch(`${this.server}/${path}${query}`, {
+				method,
+				headers,
+				body: json ? JSON.stringify(json) : null,
+				signal: this.timeout != null ? AbortSignal.timeout(this.timeout) : null
+			});
+			return await this._response(resp);
+		} catch (error) {
+			if (error instanceof require_exceptions.TeslaFleetError) throw error;
+			throw new require_exceptions.TeslaFleetConnectionError(null, null, { cause: error });
+		}
+	}
+	/**
+	* 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").then(({ response }) => response);
+	}
+	/**
+	* 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((products) => ({
+			vehicles: products.filter((product) => "vin" in product),
+			energy_sites: products.filter((product) => "energy_site_id" in product)
+		}));
+	}
+	async loadPrivateKey(path) {
+		return (await import("fs")).promises.readFile(path, "utf8").then((key) => {
+			this.accessToken = key;
+		}).catch(async () => {
+			const { privateKey: _privateKey } = (await import("crypto")).generateKeyPairSync("ec", {
+				namedCurve: "secp256r1",
+				publicKeyEncoding: {
+					type: "spki",
+					format: "pem"
+				},
+				privateKeyEncoding: {
+					type: "pkcs8",
+					format: "pem"
+				}
+			});
+		});
+	}
+};
+exports.default = TeslaFleetApi;

package/dist/teslafleetapi.d.cts

@@ -0,0 +1,64 @@
+import Charging from "./charging.cjs";
+import Energy from "./energy.cjs";
+import Partner from "./partner.cjs";
+import User from "./user.cjs";
+import Vehicle from "./vehicle.cjs";
+import { Method, Region } from "./const.cjs";
+import { EnergyProduct, ProductsResponse, VehicleProduct } from "./types/products.cjs";
+export type ProductsByType = {
+  vehicles: VehicleProduct[];
+  energy_sites: EnergyProduct[];
+};
+export default class TeslaFleetApi {
+  server: string | null;
+  accessToken: string | null;
+  charging?: Charging;
+  energy?: Energy;
+  partner?: Partner;
+  user?: User;
+  vehicle?: Vehicle;
+  debug: boolean;
+  /** Abort a request (including reading its body) after this many milliseconds; `null` waits indefinitely. */
+  timeout: number | null;
+  constructor(options: {
+    accessToken?: string;
+    region?: Region;
+    server?: string;
+    chargingScope?: boolean;
+    energyScope?: boolean;
+    partnerScope?: boolean;
+    userScope?: boolean;
+    vehicleScope?: boolean;
+    debug?: boolean;
+    timeout?: number;
+  });
+  /**
+   * 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.
+   */
+  _response(resp: Response): Promise<any>;
+  /**
+   * Make a request to the Tesla Fleet API.
+   * @param method
+   * @param path
+   * @param params
+   * @param json
+   * @returns The decoded JSON body.
+   * @throws A `TeslaFleetError` subclass for an error status, or
+   * `TeslaFleetConnectionError` (with the original error as `cause`) when the
+   * request could not complete or timed out.
+   */
+  _request(method: Method, path: string, params?: Record<string, any> | null, json?: Record<string, any> | null): Promise<any>;
+  /**
+   * Returns products mapped to user.
+   * @returns An array of products including both vehicles and energy sites.
+   */
+  products(): Promise<ProductsResponse>;
+  /**
+   * Return Tesla products separated into vehicles and energy_sites
+   * @returns A dictionary of vehicles and energy sites, each with an array of those products
+   */
+  products_by_type(): Promise<ProductsByType>;
+  loadPrivateKey(path: string): Promise<void>;
+}

package/dist/teslafleetapi.d.mts

@@ -0,0 +1,64 @@
+import Charging from "./charging.mjs";
+import Energy from "./energy.mjs";
+import Partner from "./partner.mjs";
+import User from "./user.mjs";
+import Vehicle from "./vehicle.mjs";
+import { Method, Region } from "./const.mjs";
+import { EnergyProduct, ProductsResponse, VehicleProduct } from "./types/products.mjs";
+export type ProductsByType = {
+  vehicles: VehicleProduct[];
+  energy_sites: EnergyProduct[];
+};
+export default class TeslaFleetApi {
+  server: string | null;
+  accessToken: string | null;
+  charging?: Charging;
+  energy?: Energy;
+  partner?: Partner;
+  user?: User;
+  vehicle?: Vehicle;
+  debug: boolean;
+  /** Abort a request (including reading its body) after this many milliseconds; `null` waits indefinitely. */
+  timeout: number | null;
+  constructor(options: {
+    accessToken?: string;
+    region?: Region;
+    server?: string;
+    chargingScope?: boolean;
+    energyScope?: boolean;
+    partnerScope?: boolean;
+    userScope?: boolean;
+    vehicleScope?: boolean;
+    debug?: boolean;
+    timeout?: number;
+  });
+  /**
+   * 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.
+   */
+  _response(resp: Response): Promise<any>;
+  /**
+   * Make a request to the Tesla Fleet API.
+   * @param method
+   * @param path
+   * @param params
+   * @param json
+   * @returns The decoded JSON body.
+   * @throws A `TeslaFleetError` subclass for an error status, or
+   * `TeslaFleetConnectionError` (with the original error as `cause`) when the
+   * request could not complete or timed out.
+   */
+  _request(method: Method, path: string, params?: Record<string, any> | null, json?: Record<string, any> | null): Promise<any>;
+  /**
+   * Returns products mapped to user.
+   * @returns An array of products including both vehicles and energy sites.
+   */
+  products(): Promise<ProductsResponse>;
+  /**
+   * Return Tesla products separated into vehicles and energy_sites
+   * @returns A dictionary of vehicles and energy sites, each with an array of those products
+   */
+  products_by_type(): Promise<ProductsByType>;
+  loadPrivateKey(path: string): Promise<void>;
+}