node-chargepoint 0.0.1

package/dist/index.js

@@ -0,0 +1,700 @@
+import https from 'https';
+
+// src/constants.ts
+var DISCOVERY_API = "https://discovery.chargepoint.com/discovery/v3/globalconfig";
+var VERSION = "0.0.1-alpha.0";
+var USER_AGENT = `node-chargepoint/${VERSION}`;
+
+// src/exceptions.ts
+var APIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "APIError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var CommunicationError = class extends APIError {
+  constructor(statusCode, message, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.name = "CommunicationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  statusCode;
+  body;
+};
+var LoginError = class extends CommunicationError {
+  constructor(statusCode, message, body) {
+    super(statusCode, message, body);
+    this.name = "LoginError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var InvalidSession = class extends CommunicationError {
+  constructor(statusCode = 401, message = "ChargePoint session expired. Please log in again.", body) {
+    super(statusCode, message, body);
+    this.name = "InvalidSession";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var DatadomeCaptcha = class extends APIError {
+  constructor(captchaUrl, message = "Datadome captcha protection triggered.") {
+    super(message);
+    this.captchaUrl = captchaUrl;
+    this.name = "DatadomeCaptcha";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  captchaUrl;
+};
+async function postJson(url, body) {
+  return new Promise((resolve, reject) => {
+    const bodyBuf = Buffer.from(body, "utf-8");
+    const req = https.request(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": bodyBuf.byteLength,
+          "User-Agent": USER_AGENT
+        }
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          const statusCode = res.statusCode ?? 0;
+          if (statusCode < 200 || statusCode >= 300) {
+            reject(new CommunicationError(statusCode, "Failed to fetch global configuration."));
+            return;
+          }
+          try {
+            resolve({ status: statusCode, data: JSON.parse(Buffer.concat(chunks).toString("utf-8")) });
+          } catch {
+            reject(new CommunicationError(statusCode, "Failed to parse global configuration response."));
+          }
+        });
+      }
+    );
+    req.on("error", (err) => {
+      reject(new CommunicationError(0, `Failed to reach ChargePoint discovery API: ${err.message}`));
+    });
+    req.write(bodyBuf);
+    req.end();
+  });
+}
+function endpointStr(v) {
+  const raw = v !== null && typeof v === "object" && "value" in v ? String(v.value ?? "") : typeof v === "string" ? v : "";
+  return raw.replace(/\/+$/, "");
+}
+function parseEndpoints(raw) {
+  const get = (camel, snake) => endpointStr(raw[camel] ?? raw[snake] ?? "");
+  return {
+    accountsEndpoint: get("accountsEndpoint", "accounts_endpoint"),
+    internalApiGatewayEndpoint: get("internalApiGatewayEndpoint", "internal_api_gateway_endpoint"),
+    mapcacheEndpoint: get("mapcacheEndpoint", "mapcache_endpoint"),
+    pandaWebsocketEndpoint: get("pandaWebsocketEndpoint", "panda_websocket_endpoint"),
+    paymentJavaEndpoint: get("paymentJavaEndpoint", "payment_java_endpoint"),
+    paymentPhpEndpoint: get("paymentPhpEndpoint", "payment_php_endpoint"),
+    portalDomainEndpoint: get("portalDomainEndpoint", "portal_domain_endpoint"),
+    portalSubdomain: typeof raw.portalSubdomain === "string" ? raw.portalSubdomain : typeof raw.portal_subdomain === "string" ? raw.portal_subdomain : "",
+    ssoEndpoint: get("ssoEndpoint", "sso_endpoint"),
+    webservicesEndpoint: get("webservicesEndpoint", "webservices_endpoint"),
+    websocketEndpoint: get("websocketEndpoint", "websocket_endpoint"),
+    hcpoHcmEndpoint: get("hcpoHcmEndpoint", "hcpo_hcm_endpoint")
+  };
+}
+async function fetchGlobalConfig(region = "NA") {
+  const { data } = await postJson(DISCOVERY_API, JSON.stringify({ regionCode: region }));
+  const raw = typeof data.globalConfiguration === "object" && data.globalConfiguration !== null ? data.globalConfiguration : data;
+  const endpointsRaw = raw.endPoints ?? raw.endpoints ?? {};
+  return {
+    region: typeof raw.region === "string" ? raw.region : region,
+    defaultCountry: raw.defaultCountry ?? {},
+    supportedCountries: Array.isArray(raw.supportedCountries) ? raw.supportedCountries : [],
+    defaultCurrency: raw.currency ?? raw.defaultCurrency ?? {},
+    supportedCurrencies: Array.isArray(raw.supportedCurrencies) ? raw.supportedCurrencies : [],
+    endpoints: parseEndpoints(endpointsRaw)
+  };
+}
+
+// src/session.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function sendCommand(client, action, deviceId, portNumber = 1, sessionId = 0) {
+  const actionPath = action === "start" ? "startsession" : "stopSession";
+  const body = { deviceId };
+  if (action === "stop") {
+    body.portNumber = portNumber;
+    body.sessionId = sessionId;
+  }
+  const url = `${client.globalConfig.endpoints.accountsEndpoint}/v1/driver/station/${actionPath}`;
+  const response = await client._request("POST", url, {
+    body: JSON.stringify(body),
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new CommunicationError(
+      response.status,
+      `Failed to ${action} ChargePoint session: ${text}`
+    );
+  }
+  const actionStatus = await response.json();
+  const ackId = actionStatus.ackId;
+  const ackUrl = `${client.globalConfig.endpoints.accountsEndpoint}/v1/driver/station/session/ack`;
+  let lastStatus = 0;
+  let errorMessage = `Session failed to ${action}.`;
+  let errorBody;
+  for (let attempt = 1; attempt <= 20; attempt++) {
+    const ackResponse = await client._request("POST", ackUrl, {
+      body: JSON.stringify({ ackId, action: `${action}_session` }),
+      headers: { "Content-Type": "application/json" }
+    });
+    lastStatus = ackResponse.status;
+    if (ackResponse.status === 200) {
+      return;
+    }
+    try {
+      errorBody = await ackResponse.json();
+      const msg = errorBody.errorMessage;
+      if (typeof msg === "string") errorMessage = msg;
+    } catch {
+      errorBody = void 0;
+    }
+    if (attempt < 20) {
+      await sleep(3e3);
+    }
+  }
+  throw new CommunicationError(lastStatus, errorMessage, errorBody);
+}
+function parseMsTimestamp(v) {
+  if (typeof v === "number") return new Date(v);
+  if (typeof v === "string") return new Date(Number(v));
+  return /* @__PURE__ */ new Date(0);
+}
+function parseSessionUpdates(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((u) => {
+    const item = u;
+    return {
+      energyKwh: typeof item.energy_kwh === "number" ? item.energy_kwh : 0,
+      powerKw: typeof item.power_kw === "number" ? item.power_kw : 0,
+      timestamp: parseMsTimestamp(item.timestamp)
+    };
+  });
+}
+var ChargingSession = class _ChargingSession {
+  sessionId;
+  deviceId = 0;
+  deviceName = "";
+  chargingState = "";
+  chargingTime = 0;
+  energyKwh = 0;
+  milesAdded = 0;
+  milesAddedPerHour = 0;
+  outletNumber = 0;
+  portLevel = 0;
+  powerKw = 0;
+  purpose = "";
+  currencyIsoCode = "";
+  paymentCompleted = false;
+  paymentType = "";
+  pricingSpecId = 0;
+  totalAmount = 0;
+  apiFlag = false;
+  enableStopCharging = false;
+  hasChargingReceipt = false;
+  hasUtilityInfo = false;
+  isHomeCharger = false;
+  isPurposeFinalized = false;
+  stopChargeSupported = false;
+  companyId = 0;
+  companyName = "";
+  latitude = 0;
+  longitude = 0;
+  address = "";
+  city = "";
+  stateName = "";
+  country = "";
+  zipcode = "";
+  updatePeriod = 0;
+  startTime = null;
+  lastUpdateDataTimestamp = null;
+  updateData = null;
+  utility = null;
+  vehicleInfo = null;
+  _client = null;
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+  }
+  /** @internal */
+  _setClient(client) {
+    this._client = client;
+  }
+  /** @internal Apply raw session data from the driver-bff API (snake_case keys). */
+  _apply(data) {
+    if (data.device_id !== void 0) this.deviceId = data.device_id;
+    if (data.device_name !== void 0) this.deviceName = data.device_name;
+    if (data.current_charging !== void 0) this.chargingState = data.current_charging;
+    if (data.charging_time !== void 0) this.chargingTime = data.charging_time;
+    if (data.energy_kwh !== void 0) this.energyKwh = data.energy_kwh;
+    if (data.miles_added !== void 0) this.milesAdded = data.miles_added;
+    if (data.miles_added_per_hour !== void 0) this.milesAddedPerHour = data.miles_added_per_hour;
+    if (data.outlet_number !== void 0) this.outletNumber = data.outlet_number;
+    if (data.port_level !== void 0) this.portLevel = data.port_level;
+    if (data.power_kw !== void 0) this.powerKw = data.power_kw;
+    if (data.purpose !== void 0) this.purpose = data.purpose;
+    if (data.currency_iso_code !== void 0) this.currencyIsoCode = String(data.currency_iso_code);
+    if (data.payment_completed !== void 0) this.paymentCompleted = data.payment_completed;
+    if (data.payment_type !== void 0) this.paymentType = data.payment_type;
+    if (data.pricing_spec_id !== void 0) this.pricingSpecId = data.pricing_spec_id;
+    if (data.total_amount !== void 0) this.totalAmount = data.total_amount;
+    if (data.api_flag !== void 0) this.apiFlag = data.api_flag;
+    if (data.enable_stop_charging !== void 0) this.enableStopCharging = data.enable_stop_charging;
+    if (data.has_charging_receipt !== void 0) this.hasChargingReceipt = data.has_charging_receipt;
+    if (data.has_utility_info !== void 0) this.hasUtilityInfo = data.has_utility_info;
+    if (data.is_home_charger !== void 0) this.isHomeCharger = data.is_home_charger;
+    if (data.is_purpose_finalized !== void 0) this.isPurposeFinalized = data.is_purpose_finalized;
+    if (data.stop_charge_supported !== void 0) this.stopChargeSupported = data.stop_charge_supported;
+    if (data.company_id !== void 0) this.companyId = data.company_id;
+    if (data.company_name !== void 0) this.companyName = data.company_name;
+    if (data.lat !== void 0) this.latitude = data.lat;
+    if (data.lon !== void 0) this.longitude = data.lon;
+    if (data.address1 !== void 0) this.address = data.address1;
+    if (data.city !== void 0) this.city = data.city;
+    if (data.state_name !== void 0) this.stateName = data.state_name;
+    if (data.country !== void 0) this.country = data.country;
+    if (data.zipcode !== void 0) this.zipcode = data.zipcode;
+    if (data.update_period !== void 0) this.updatePeriod = data.update_period;
+    if (data.start_time !== void 0) this.startTime = parseMsTimestamp(data.start_time);
+    if (data.last_update_data_timestamp !== void 0) {
+      this.lastUpdateDataTimestamp = parseMsTimestamp(data.last_update_data_timestamp);
+    }
+    if (data.update_data !== void 0) this.updateData = parseSessionUpdates(data.update_data);
+    if (data.utility !== void 0) this.utility = data.utility ?? null;
+    if (data.vehicle_info !== void 0) this.vehicleInfo = data.vehicle_info ?? null;
+  }
+  async refresh() {
+    if (!this._client) throw new Error("ChargingSession client not set.");
+    const url = `${this._client.globalConfig.endpoints.internalApiGatewayEndpoint}/driver-bff/v1/sessions/${this.sessionId}`;
+    const response = await this._client._request("POST", url, {
+      body: JSON.stringify({
+        charging_status: { session_id: this.sessionId, mfhs: [] }
+      }),
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get charging session data.");
+    }
+    const json = await response.json();
+    const status = json.charging_status;
+    if (!status || "error_message" in status || "error" in status) {
+      throw new CommunicationError(response.status, "Failed to get charging session data.");
+    }
+    this._apply(status);
+  }
+  async stop() {
+    if (!this._client) throw new Error("ChargingSession client not set.");
+    await sendCommand(
+      this._client,
+      "stop",
+      this.deviceId,
+      this.outletNumber,
+      this.sessionId
+    );
+  }
+  static async start(deviceId, client) {
+    await sendCommand(client, "start", deviceId);
+    const status = await client.getUserChargingStatus();
+    if (!status) {
+      throw new APIError("No active charging session found after start command.");
+    }
+    const session = new _ChargingSession(status.sessionId);
+    session._setClient(client);
+    await session.refresh();
+    return session;
+  }
+};
+
+// src/client.ts
+function parseMsTimestamp2(v) {
+  if (typeof v === "number") return new Date(v);
+  if (typeof v === "string") return new Date(Number(v));
+  return /* @__PURE__ */ new Date(0);
+}
+var ChargePoint = class _ChargePoint {
+  globalConfig;
+  _username;
+  _coulombToken = null;
+  _region;
+  _userId = null;
+  /** The current session token. Save this after login to avoid re-authenticating. */
+  get coulombToken() {
+    return this._coulombToken;
+  }
+  constructor(username, globalConfig, region) {
+    this._username = username;
+    this.globalConfig = globalConfig;
+    this._region = region;
+  }
+  static async create(username, options = {}) {
+    const region = options.region ?? "NA";
+    const config = await fetchGlobalConfig(region);
+    const client = new _ChargePoint(username, config, region);
+    if (options.coulombToken) {
+      client._setToken(options.coulombToken, region);
+    }
+    return client;
+  }
+  _setToken(token, region) {
+    this._coulombToken = token;
+    this._region = region;
+  }
+  /** @internal Used by session.ts and tests. */
+  async _request(method, url, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("user-agent", USER_AGENT);
+    if (!headers.has("content-type") && method !== "GET") {
+      headers.set("content-type", "application/json");
+    }
+    if (this._coulombToken) {
+      headers.set("cookie", `coulomb_sess=${this._coulombToken}`);
+      headers.set("cp-session-type", "CP_SESSION_TOKEN");
+      headers.set("cp-session-token", this._coulombToken);
+      headers.set("cp-region", this._region);
+    }
+    const response = await fetch(url, { ...init, method, headers });
+    const setCookies = typeof response.headers.getSetCookie === "function" ? response.headers.getSetCookie() : [response.headers.get("set-cookie") ?? ""].filter(Boolean);
+    for (const cookie of setCookies) {
+      const match = /^coulomb_sess=([^;]+)/.exec(cookie);
+      if (match) {
+        this._coulombToken = match[1] ?? null;
+        break;
+      }
+    }
+    if (response.status === 401) {
+      throw new InvalidSession(401, "ChargePoint session expired. Please log in again.");
+    }
+    if (response.status === 403) {
+      let body;
+      try {
+        body = await response.clone().json();
+      } catch {
+      }
+      const captchaUrl = body?.url;
+      if (typeof captchaUrl === "string" && captchaUrl.includes("datadome")) {
+        throw new DatadomeCaptcha(captchaUrl);
+      }
+    }
+    return response;
+  }
+  // ---------------------------------------------------------------------------
+  // Authentication
+  // ---------------------------------------------------------------------------
+  async loginWithPassword(password) {
+    const url = `${this.globalConfig.endpoints.ssoEndpoint}/v1/user/login`;
+    const response = await this._request("POST", url, {
+      body: JSON.stringify({ user_name: this._username, password }),
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+      }
+      throw new LoginError(response.status, "Failed to login with password.", body);
+    }
+    await response.text();
+    if (!this._coulombToken) {
+      throw new LoginError(response.status, "Login succeeded but no session token was returned.");
+    }
+  }
+  async loginWithSsoSession(ssoJwt) {
+    const url = `${this.globalConfig.endpoints.portalDomainEndpoint}/index.php/nghelper/getSession`;
+    const response = await this._request("GET", url, {
+      headers: {
+        cookie: `auth-session=${ssoJwt}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+      }
+      throw new LoginError(response.status, "Failed to login with SSO session.", body);
+    }
+    await response.text();
+  }
+  async logout() {
+    const url = `${this.globalConfig.endpoints.ssoEndpoint}/v1/user/logout`;
+    try {
+      await this._request("POST", url);
+    } finally {
+      this._coulombToken = null;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Account
+  // ---------------------------------------------------------------------------
+  async getAccount() {
+    const url = `${this.globalConfig.endpoints.accountsEndpoint}/v1/driver/profile/user`;
+    const response = await this._request("GET", url);
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get account information.");
+    }
+    const data = await response.json();
+    if (data.user?.userId) {
+      this._userId = data.user.userId;
+    }
+    return data;
+  }
+  async getVehicles() {
+    const url = `${this.globalConfig.endpoints.accountsEndpoint}/v1/driver/vehicle`;
+    const response = await this._request("GET", url);
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get vehicles.");
+    }
+    const data = await response.json();
+    return Array.isArray(data.vehicles) ? data.vehicles : [];
+  }
+  async getUserChargingStatus() {
+    const url = `${this.globalConfig.endpoints.mapcacheEndpoint}/v2`;
+    const response = await this._request("POST", url, {
+      body: JSON.stringify({ user_status: { timestamp: Date.now() } }),
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get user charging status.");
+    }
+    const data = await response.json();
+    const userStatus = data.user_status;
+    if (!userStatus) return null;
+    const charging = userStatus.charging_status;
+    if (!charging) return null;
+    const stations = Array.isArray(charging.stations) ? charging.stations.map((s) => ({
+      id: s.id,
+      name: typeof s.name === "string" ? s.name : "",
+      latitude: typeof s.lat === "number" ? s.lat : s.latitude ?? 0,
+      longitude: typeof s.lon === "number" ? s.lon : s.longitude ?? 0
+    })) : [];
+    return {
+      sessionId: charging.session_id,
+      startTime: parseMsTimestamp2(charging.start_time),
+      state: typeof charging.current_charging === "string" ? charging.current_charging : "",
+      stations
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Home charger helpers
+  // ---------------------------------------------------------------------------
+  async ensureUserId() {
+    if (this._userId !== null) return this._userId;
+    const account = await this.getAccount();
+    return account.user.userId;
+  }
+  async getHomeChargers() {
+    const userId = await this.ensureUserId();
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/configuration/users/${userId}/chargers`;
+    const response = await this._request("GET", url);
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+      }
+      throw new CommunicationError(response.status, "Failed to get home chargers.", body);
+    }
+    const data = await response.json();
+    const arr = Array.isArray(data.data) ? data.data : Array.isArray(data.chargers) ? data.chargers : [];
+    return arr.map((c) => {
+      const id = c.id ?? c.chargerId ?? c.charger_id;
+      return typeof id === "number" ? id : Number(id);
+    });
+  }
+  async getHomeChargerStatus(chargerId) {
+    const userId = await this.ensureUserId();
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/configuration/users/${userId}/chargers/${chargerId}/status`;
+    const response = await this._request("GET", url);
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get home charger status.");
+    }
+    const data = await response.json();
+    const amp = data.chargeAmperageSettings ?? {};
+    return {
+      chargerId,
+      // not echoed by the API; inject from parameter
+      brand: String(data.brand ?? ""),
+      model: String(data.model ?? ""),
+      macAddress: String(data.macAddress ?? ""),
+      chargingStatus: String(data.chargingStatus ?? ""),
+      isPluggedIn: Boolean(data.isPluggedIn),
+      isConnected: Boolean(data.isConnected),
+      isReminderEnabled: Boolean(data.isReminderEnabled),
+      plugInReminderTime: String(data.plugInReminderTime ?? ""),
+      hasUtilityInfo: Boolean(data.hasUtilityInfo),
+      isDuringScheduledTime: Boolean(data.isDuringScheduledTime),
+      amperageLimit: Number(amp.chargeLimit ?? data.amperageLimit ?? 0),
+      possibleAmperageLimits: (amp.possibleChargeLimit ?? data.possibleAmperageLimits ?? []).map(Number)
+    };
+  }
+  async getHomeChargerTechnicalInfo(chargerId) {
+    const userId = await this.ensureUserId();
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/configuration/users/${userId}/chargers/${chargerId}/technical-info`;
+    const response = await this._request("GET", url);
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get home charger technical info.");
+    }
+    return await response.json();
+  }
+  async getHomeChargerConfig(chargerId) {
+    const userId = await this.ensureUserId();
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/configuration/users/${userId}/chargers/${chargerId}/configurations`;
+    const response = await this._request("GET", url);
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get home charger configuration.");
+    }
+    const data = await response.json();
+    const s = data.settings ?? data;
+    const rawLed = s.led?.brightness ?? s.ledBrightness ?? {};
+    const level = typeof rawLed.level === "string" ? Number(rawLed.level) : Number(rawLed.level ?? rawLed.currentBrightnessSettings ?? 0);
+    const supportedLevels = Array.isArray(rawLed.supportedLevels) ? rawLed.supportedLevels.map(Number) : [];
+    return {
+      serialNumber: String(s.serialNumber ?? ""),
+      macAddress: String(s.macAddress ?? ""),
+      stationNickname: String(s.stationNickname ?? ""),
+      streetAddress: String(s.streetAddress ?? ""),
+      hasUtilityInfo: Boolean(s.hasUtilityInfo),
+      utility: s.utility ?? null,
+      // API may return boolean true/false or string "ON"/"OFF"
+      indicatorLightEcoMode: s.indicatorLightEcoMode === true || s.indicatorLightEcoMode === "ON",
+      flashlightReset: Boolean(s.flashlightReset),
+      worksWithNest: Boolean(s.worksWithNest),
+      isPairedWithNest: Boolean(s.isPairedWithNest),
+      isInstalledByInstaller: Boolean(s.isInstalledByInstaller),
+      ledBrightness: {
+        level,
+        inProgress: Boolean(rawLed.inProgress),
+        supportedLevels,
+        isEnabled: rawLed.isEnabled !== false
+      }
+    };
+  }
+  async getHomeChargerSchedule(chargerId) {
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/schedule/charger/${chargerId}/schedule`;
+    const response = await this._request("GET", url);
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get home charger schedule.");
+    }
+    return await response.json();
+  }
+  async setHomeChargerSchedule(chargerId, weekdayStart, weekdayEnd, weekendStart, weekendEnd) {
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/schedule/charger/${chargerId}/schedule`;
+    const response = await this._request("PUT", url, {
+      body: JSON.stringify({
+        scheduleEnabled: true,
+        userSchedule: {
+          weekdays: { startTime: weekdayStart, endTime: weekdayEnd },
+          weekends: { startTime: weekendStart, endTime: weekendEnd }
+        }
+      }),
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to set home charger schedule.");
+    }
+    return await response.json();
+  }
+  async disableHomeChargerSchedule(chargerId) {
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/schedule/charger/${chargerId}/schedule`;
+    const response = await this._request("PUT", url, {
+      body: JSON.stringify({ scheduleEnabled: false }),
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to disable home charger schedule.");
+    }
+    await response.text();
+  }
+  async setAmperageLimit(chargerId, amperageLimit) {
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/configuration/chargers/${chargerId}/charge-amperage-limit`;
+    const response = await this._request("PUT", url, {
+      body: JSON.stringify({ amperageLimit }),
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to set amperage limit.");
+    }
+    await response.text();
+  }
+  async setLedBrightness(chargerId, level) {
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/configuration/chargers/${chargerId}/led-brightness`;
+    const response = await this._request("PUT", url, {
+      body: JSON.stringify({ level }),
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to set LED brightness.");
+    }
+    await response.text();
+  }
+  async restartHomeCharger(chargerId) {
+    const userId = await this.ensureUserId();
+    const url = `${this.globalConfig.endpoints.hcpoHcmEndpoint}/api/v1/configuration/users/${userId}/chargers/${chargerId}/restart`;
+    const response = await this._request("POST", url);
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to restart home charger.");
+    }
+    await response.text();
+  }
+  // ---------------------------------------------------------------------------
+  // Charging sessions
+  // ---------------------------------------------------------------------------
+  async getChargingSession(sessionId) {
+    const session = new ChargingSession(sessionId);
+    session._setClient(this);
+    await session.refresh();
+    return session;
+  }
+  async startChargingSession(deviceId) {
+    return ChargingSession.start(deviceId, this);
+  }
+  // ---------------------------------------------------------------------------
+  // Stations
+  // ---------------------------------------------------------------------------
+  async getStation(deviceId) {
+    const url = `${this.globalConfig.endpoints.mapcacheEndpoint}/v3/station/info?deviceId=${deviceId}&use_cache=false`;
+    const response = await this._request("GET", url);
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get station info.");
+    }
+    return await response.json();
+  }
+  async getNearbyStations(bounds, filter = {}) {
+    const url = `${this.globalConfig.endpoints.mapcacheEndpoint}/v2`;
+    const stationList = {
+      ne_lat: bounds.neLat,
+      ne_lon: bounds.neLon,
+      sw_lat: bounds.swLat,
+      sw_lon: bounds.swLon,
+      ...filter
+    };
+    const response = await this._request("POST", url, {
+      body: JSON.stringify({ station_list: stationList }),
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new CommunicationError(response.status, "Failed to get nearby stations.");
+    }
+    const data = await response.json();
+    const list = data.station_list;
+    return Array.isArray(list?.stations) ? list.stations : [];
+  }
+};
+
+export { APIError, ChargePoint, ChargingSession, CommunicationError, DatadomeCaptcha, InvalidSession, LoginError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map