homebridge-kia-eu 1.0.0

package/README.md

@@ -0,0 +1,134 @@
+# homebridge-kia-eu
+
+Homebridge plugin for **Kia Connect (UVO) vehicles in Europe**, powered by
+[bluelinky](https://github.com/Hacksore/bluelinky).
+
+This is an EU adaptation of [`jfriend615/homebridge-kia`](https://github.com/jfriend615/homebridge-kia)
+(which targets the US Kia Connect API). The HomeKit accessory layer is shared; the
+Kia API client was replaced with `bluelinky` so it speaks to Kia's European servers
+(OAuth2 + control PIN + request stamping), and remote climate uses Celsius.
+
+> ⚠️ The EU Kia/Hyundai API is unofficial and occasionally changes. `bluelinky`'s EU
+> support is community-maintained and can break when Kia updates its app. If logins
+> suddenly fail, check for a newer `bluelinky` release.
+
+## Features
+
+- Door lock / unlock
+- Remote climate start / stop (Celsius)
+- EV battery charge level and charging state (or 12V battery for combustion cars)
+- Low fuel warning, engine/ignition state, tire pressure warning
+- Door, window, hood, and trunk sensors
+
+## Requirements
+
+- Node.js `20.18.0` or newer
+- Homebridge `1.8.0` or newer
+- A **Kia (European) account** with an **active Kia Connect / UVO subscription**
+- Your Kia Connect **PIN** (set in the Kia app) — the EU API requires it for status reads and remote commands
+
+> ℹ️ The PIN is validated server-side and has a limited number of attempts before a
+> temporary lockout. Make sure it is correct before starting Homebridge.
+
+## Installation
+
+Install through the Homebridge UI (search for `homebridge-kia-eu`), or with npm:
+
+```bash
+npm install -g homebridge-kia-eu
+```
+
+Then restart Homebridge.
+
+## Configuration
+
+Configure through the Homebridge UI, or add a platform block to `config.json`:
+
+```json
+{
+  "platform": "KiaConnectEU",
+  "name": "Kia Connect EU",
+  "username": "you@example.com",
+  "password": "your-password",
+  "pin": "1234",
+  "language": "en",
+  "vehicleIndex": 0,
+  "pollIntervalMinutes": 30,
+  "showLock": true,
+  "showClimate": true,
+  "showStatus": true,
+  "showBody": false,
+  "showBattery": true,
+  "climateTemperature": 21
+}
+```
+
+| Setting | Description |
+| --- | --- |
+| `username` | Kia Connect email |
+| `password` | Kia Connect password |
+| `pin` | Kia Connect PIN (numeric). Required for status reads and commands |
+| `language` | EU UI language (`en`, `de`, `fr`, …). Default `en` |
+| `vehicleIndex` | Which vehicle to use if the account has several (0 = first) |
+| `pollIntervalMinutes` | Status refresh interval, minimum `5` |
+| `showLock` | Show the HomeKit lock service |
+| `showClimate` | Show the HomeKit climate switch |
+| `showStatus` | Show low-fuel, engine, and tire-warning sensors |
+| `showBody` | Show door, window, hood, and trunk sensors |
+| `showBattery` | Show the battery service (EV charge, or 12V) |
+| `climateTemperature` | Remote climate target temperature in °C (14–30) |
+
+## HomeKit services
+
+Up to five accessories are created per vehicle:
+
+- `${vehicleName} Lock` — `LockMechanism`
+- `${vehicleName} Climate` — `Switch`
+- `${vehicleName} Status` — `LeakSensor` (low fuel), `OccupancySensor` (engine),
+  `LeakSensor` (tire pressure), plus `HumiditySensor`/`TemperatureSensor` placeholders
+- `${vehicleName} Body` — `ContactSensor` services for doors, windows, hood, trunk
+- `${vehicleName} Battery` — `Battery` (EV charge + charging state, or 12V battery)
+
+## EU API limitations
+
+The European API does **not** expose a few things the US API does:
+
+- **Ambient outside temperature** — the temperature sensor will not report a value.
+- **Fuel percentage** — only a low-fuel warning and distance-to-empty are available.
+
+For EVs, the battery service reports the high-voltage traction battery's charge and
+whether it is charging.
+
+## Rate limiting & battery care
+
+The EU API is rate limited (roughly 200 calls/day) and waking the car to refresh
+status repeatedly can drain its 12V battery. This plugin:
+
+- polls **cached** server status (does not wake the car) on the configured interval;
+- only forces a live refresh immediately after you issue a lock/climate command.
+
+Keep `pollIntervalMinutes` conservative (the default is 30).
+
+## Authentication notes
+
+Unlike the US plugin, there is **no OTP step**. The plugin logs in with your email,
+password, and PIN on Homebridge start. If you change your password in the Kia app,
+update it here and restart Homebridge.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm run lint
+npm test
+```
+
+## Credits
+
+- Original US plugin: [jfriend615/homebridge-kia](https://github.com/jfriend615/homebridge-kia)
+- EU API library: [Hacksore/bluelinky](https://github.com/Hacksore/bluelinky)
+
+## License
+
+ISC

package/config.schema.json

@@ -0,0 +1,127 @@
+{
+  "pluginAlias": "KiaConnectEU",
+  "pluginType": "platform",
+  "singular": true,
+  "headerDisplay": "Kia Connect (UVO) for Europe, powered by [bluelinky](https://github.com/Hacksore/bluelinky). Requires an active Kia Connect subscription. Your account PIN is needed for remote commands.",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "name": {
+        "title": "Name",
+        "type": "string",
+        "default": "Kia Connect EU",
+        "required": true
+      },
+      "username": {
+        "title": "Kia Connect Email",
+        "type": "string",
+        "format": "email",
+        "required": true
+      },
+      "password": {
+        "title": "Kia Connect Password",
+        "type": "string",
+        "required": true
+      },
+      "pin": {
+        "title": "Kia Connect PIN",
+        "type": "string",
+        "required": true,
+        "pattern": "^[0-9]{4,6}$",
+        "description": "Numeric PIN from the Kia Connect app. Required to authorise remote commands."
+      },
+      "language": {
+        "title": "Language",
+        "type": "string",
+        "default": "en",
+        "oneOf": [
+          { "title": "English", "enum": ["en"] },
+          { "title": "Deutsch", "enum": ["de"] },
+          { "title": "Français", "enum": ["fr"] },
+          { "title": "Italiano", "enum": ["it"] },
+          { "title": "Español", "enum": ["es"] },
+          { "title": "Nederlands", "enum": ["nl"] },
+          { "title": "Polski", "enum": ["pl"] },
+          { "title": "Čeština", "enum": ["cs"] },
+          { "title": "Dansk", "enum": ["da"] },
+          { "title": "Suomi", "enum": ["fi"] },
+          { "title": "Magyar", "enum": ["hu"] },
+          { "title": "Norsk", "enum": ["no"] },
+          { "title": "Slovenčina", "enum": ["sk"] },
+          { "title": "Svenska", "enum": ["sv"] }
+        ]
+      },
+      "pollIntervalMinutes": {
+        "title": "Poll Interval (minutes)",
+        "type": "integer",
+        "default": 30,
+        "minimum": 5,
+        "description": "How often to refresh cached vehicle status. Keep this conservative — the EU API is rate limited (~200 calls/day)."
+      },
+      "showLock": {
+        "title": "Show Door Lock",
+        "type": "boolean",
+        "default": true
+      },
+      "showClimate": {
+        "title": "Show Remote Climate",
+        "type": "boolean",
+        "default": true
+      },
+      "showStatus": {
+        "title": "Show Vehicle Sensors",
+        "type": "boolean",
+        "default": true,
+        "description": "Low fuel warning, engine/ignition state, and tire pressure. (Outside temperature and fuel percentage are not provided by the EU API.)"
+      },
+      "showBody": {
+        "title": "Show Body Sensors",
+        "type": "boolean",
+        "default": false,
+        "description": "Expose door, window, hood, and trunk sensors."
+      },
+      "showBattery": {
+        "title": "Show Battery",
+        "type": "boolean",
+        "default": true,
+        "description": "EV high-voltage battery charge and charging state where available, otherwise the 12V battery."
+      },
+      "climateTemperature": {
+        "title": "Remote Climate Temperature (°C)",
+        "type": "integer",
+        "default": 21,
+        "minimum": 14,
+        "maximum": 30,
+        "description": "Target temperature when starting climate control remotely."
+      },
+      "vehicleIndex": {
+        "title": "Vehicle Index",
+        "type": "integer",
+        "default": 0,
+        "minimum": 0,
+        "description": "If you have multiple vehicles, specify the index (0 = first vehicle)"
+      }
+    }
+  },
+  "layout": [
+    "username",
+    "password",
+    "pin",
+    "language",
+    { "key": "pollIntervalMinutes" },
+    { "key": "vehicleIndex" },
+    {
+      "type": "fieldset",
+      "title": "Accessory Visibility",
+      "expandable": true,
+      "items": [
+        "showLock",
+        "showClimate",
+        "showStatus",
+        "showBody",
+        "showBattery"
+      ]
+    },
+    { "key": "climateTemperature" }
+  ]
+}

package/dist/src/accessory-layout.d.ts

@@ -0,0 +1,12 @@
+import type { KiaConnectConfig } from './kia/types.js';
+export type AccessoryCategory = 'lock' | 'climate' | 'status' | 'body' | 'battery';
+export declare const ACCESSORY_CATEGORIES: readonly AccessoryCategory[];
+export interface AccessoryPresentation {
+    enabledCategories: AccessoryCategory[];
+    showLock: boolean;
+    showClimate: boolean;
+    showStatus: boolean;
+    showBody: boolean;
+    showBattery: boolean;
+}
+export declare function resolveAccessoryPresentation(config: KiaConnectConfig): AccessoryPresentation;

package/dist/src/accessory-layout.js

@@ -0,0 +1,36 @@
+export const ACCESSORY_CATEGORIES = [
+    'lock',
+    'climate',
+    'status',
+    'body',
+    'battery',
+];
+export function resolveAccessoryPresentation(config) {
+    const showLock = config.showLock ?? true;
+    const showClimate = config.showClimate ?? true;
+    const showStatus = config.showStatus ?? true;
+    const showBody = config.showBody ?? false;
+    const showBattery = config.showBattery ?? true;
+    return {
+        enabledCategories: ACCESSORY_CATEGORIES.filter((category) => {
+            switch (category) {
+                case 'lock':
+                    return showLock;
+                case 'climate':
+                    return showClimate;
+                case 'status':
+                    return showStatus;
+                case 'body':
+                    return showBody;
+                case 'battery':
+                    return showBattery;
+            }
+        }),
+        showLock,
+        showClimate,
+        showStatus,
+        showBody,
+        showBattery,
+    };
+}
+//# sourceMappingURL=accessory-layout.js.map

package/dist/src/accessory-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessory-layout.js","sourceRoot":"","sources":["../../src/accessory-layout.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,oBAAoB,GAAiC;IAChE,MAAM;IACN,SAAS;IACT,QAAQ;IACR,MAAM;IACN,SAAS;CACV,CAAC;AAWF,MAAM,UAAU,4BAA4B,CAAC,MAAwB;IACnE,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC;IACzC,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,IAAI,CAAC;IAC/C,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC;IAC7C,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,KAAK,CAAC;IAC1C,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,IAAI,CAAC;IAE/C,OAAO;QACL,iBAAiB,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC1D,QAAQ,QAAQ,EAAE,CAAC;gBACnB,KAAK,MAAM;oBACT,OAAO,QAAQ,CAAC;gBAClB,KAAK,SAAS;oBACZ,OAAO,WAAW,CAAC;gBACrB,KAAK,QAAQ;oBACX,OAAO,UAAU,CAAC;gBACpB,KAAK,MAAM;oBACT,OAAO,QAAQ,CAAC;gBAClB,KAAK,SAAS;oBACZ,OAAO,WAAW,CAAC;YACrB,CAAC;QACH,CAAC,CAAC;QACF,QAAQ;QACR,WAAW;QACX,UAAU;QACV,QAAQ;QACR,WAAW;KACZ,CAAC;AACJ,CAAC"}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+import type { API } from 'homebridge';
+declare const _default: (api: API) => void;
+export default _default;

package/dist/src/index.js

@@ -0,0 +1,6 @@
+import { KiaConnectPlatform } from './platform.js';
+import { PLATFORM_NAME } from './settings.js';
+export default (api) => {
+    api.registerPlatform(PLATFORM_NAME, KiaConnectPlatform);
+};
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,eAAe,CAAC,GAAQ,EAAE,EAAE;IAC1B,GAAG,CAAC,gBAAgB,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;AAC1D,CAAC,CAAC"}

package/dist/src/kia/client.d.ts

@@ -0,0 +1,87 @@
+import type { Logger } from 'homebridge';
+import { type ClimateOptions, type LoginResult, type VehicleState, type VehicleSummary } from './types.js';
+export interface KiaClientOptions {
+    username: string;
+    password: string;
+    pin: string;
+    language?: string;
+}
+/**
+ * Subset of bluelinky's RawVehicleStatus (region EU) that we actually read.
+ * Declared locally so we don't couple to bluelinky's internal type paths and so
+ * the mapper degrades gracefully when fields are missing.
+ */
+interface EuRawStatus {
+    doorLock?: boolean;
+    doorOpen?: Record<string, number | undefined>;
+    windowOpen?: Record<string, number | undefined>;
+    trunkOpen?: boolean;
+    hoodOpen?: boolean;
+    engine?: boolean;
+    airCtrlOn?: boolean;
+    defrost?: boolean;
+    lowFuelLight?: boolean;
+    battery?: {
+        batSoc?: number;
+    };
+    dte?: {
+        value?: number;
+        unit?: number;
+    };
+    tirePressureLamp?: Record<string, number | undefined>;
+    evStatus?: {
+        batteryCharge?: boolean;
+        batteryStatus?: number;
+        batteryPlugin?: number;
+        drvDistance?: Array<{
+            rangeByFuel?: {
+                evModeRange?: {
+                    value?: number;
+                };
+                totalAvailableRange?: {
+                    value?: number;
+                };
+            };
+        }>;
+    };
+    lastStatusDate?: string;
+    dateTime?: string;
+}
+/**
+ * Maps a bluelinky EU raw status payload into the region-agnostic VehicleState
+ * the HomeKit accessory layer consumes.
+ *
+ * Note: the EU API does not expose ambient outside temperature or a fuel
+ * percentage, so those remain null. EV charge, charging state and range are
+ * available and are surfaced through the battery accessory.
+ */
+export declare function mapRawStatus(raw: EuRawStatus | null | undefined): VehicleState;
+export declare class KiaApiClient {
+    private readonly log;
+    private readonly options;
+    private client?;
+    private readonly vehicles;
+    private summaries;
+    constructor(log: Logger, options: KiaClientOptions);
+    /**
+     * Logs in via bluelinky. The constructor auto-logs-in and emits 'ready' with
+     * the account's vehicles, or 'error' on failure.
+     */
+    login(): Promise<LoginResult>;
+    getVehicles(): Promise<VehicleSummary[]>;
+    getVehicleStatus(vehicleKey: string, refresh?: boolean): Promise<VehicleState>;
+    lockDoors(vehicleKey: string): Promise<string>;
+    unlockDoors(vehicleKey: string): Promise<string>;
+    startClimate(vehicleKey: string, options?: ClimateOptions): Promise<string>;
+    stopClimate(vehicleKey: string): Promise<string>;
+    /**
+     * bluelinky resolves command calls once the server accepts them, so there is
+     * no separate transaction to poll. Retained for accessory-layer compatibility.
+     */
+    waitForAction(_vehicleKey: string, _actionId: string): Promise<boolean>;
+    private indexVehicles;
+    private safeCall;
+    private requireVehicle;
+    private wrapError;
+}
+export {};

package/dist/src/kia/client.js

@@ -0,0 +1,264 @@
+import { BlueLinky } from 'bluelinky';
+import { AuthenticationError, KiaApiError, } from './types.js';
+import { CLIMATE_DURATION_MINUTES, DEFAULT_CLIMATE_TEMP_C, DEFAULT_LANGUAGE, LOGIN_TIMEOUT_MS, MAX_CLIMATE_TEMP_C, MIN_CLIMATE_TEMP_C, } from '../settings.js';
+function parseNumber(value) {
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    const num = Number(value);
+    return Number.isNaN(num) ? null : num;
+}
+function isOpen(value) {
+    return (value ?? 0) !== 0;
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function errorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+const AUTH_HINTS = ['token', 'auth', 'login', 'session', 'credential', 'pin', '401', '403'];
+function looksLikeAuthError(message) {
+    const lower = message.toLowerCase();
+    return AUTH_HINTS.some((hint) => lower.includes(hint));
+}
+/**
+ * Maps a bluelinky EU raw status payload into the region-agnostic VehicleState
+ * the HomeKit accessory layer consumes.
+ *
+ * Note: the EU API does not expose ambient outside temperature or a fuel
+ * percentage, so those remain null. EV charge, charging state and range are
+ * available and are surfaced through the battery accessory.
+ */
+export function mapRawStatus(raw) {
+    const doors = raw?.doorOpen ?? {};
+    const windows = raw?.windowOpen ?? {};
+    const tire = raw?.tirePressureLamp ?? {};
+    const ev = raw?.evStatus;
+    const evRange = ev?.drvDistance?.[0]?.rangeByFuel?.evModeRange?.value;
+    return {
+        // Doors (1 = open)
+        frontLeftDoorOpen: isOpen(doors.frontLeft),
+        frontRightDoorOpen: isOpen(doors.frontRight),
+        rearLeftDoorOpen: isOpen(doors.backLeft),
+        rearRightDoorOpen: isOpen(doors.backRight),
+        hoodOpen: raw?.hoodOpen === true,
+        trunkOpen: raw?.trunkOpen === true,
+        // Lock
+        locked: raw?.doorLock === true,
+        // Engine / climate
+        engineRunning: raw?.engine === true,
+        airControlOn: raw?.airCtrlOn === true,
+        defrostOn: raw?.defrost === true,
+        // Ambient temperature is not provided by the EU API.
+        outsideTemperature: null,
+        // 12V battery
+        batteryPercentage: parseNumber(raw?.battery?.batSoc),
+        // EV high-voltage battery
+        evBatteryPercentage: parseNumber(ev?.batteryStatus),
+        evCharging: ev?.batteryCharge === true,
+        evPluggedIn: isOpen(ev?.batteryPlugin),
+        evRange: parseNumber(evRange),
+        // Fuel — percentage is not exposed; distance-to-empty is.
+        fuelLevel: null,
+        fuelLevelLow: raw?.lowFuelLight === true,
+        fuelDrivingRange: parseNumber(raw?.dte?.value),
+        // Windows (1 = open)
+        frontLeftWindowOpen: isOpen(windows.frontLeft),
+        frontRightWindowOpen: isOpen(windows.frontRight),
+        rearLeftWindowOpen: isOpen(windows.backLeft),
+        rearRightWindowOpen: isOpen(windows.backRight),
+        // Tire pressure warning (any lamp lit)
+        tirePressureWarning: Object.values(tire).some((v) => (v ?? 0) !== 0),
+        // Odometer / location are fetched on demand elsewhere; not part of status.
+        odometer: null,
+        latitude: null,
+        longitude: null,
+        // Meta
+        lastUpdated: raw?.lastStatusDate ?? raw?.dateTime ?? null,
+    };
+}
+export class KiaApiClient {
+    log;
+    options;
+    client;
+    vehicles = new Map();
+    summaries = [];
+    constructor(log, options) {
+        this.log = log;
+        this.options = options;
+    }
+    /**
+     * Logs in via bluelinky. The constructor auto-logs-in and emits 'ready' with
+     * the account's vehicles, or 'error' on failure.
+     */
+    login() {
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                resolve(result);
+            };
+            const timer = setTimeout(() => {
+                finish({ success: false, error: 'Timed out waiting for Kia Connect login' });
+            }, LOGIN_TIMEOUT_MS);
+            try {
+                const config = {
+                    username: this.options.username,
+                    password: this.options.password,
+                    pin: this.options.pin,
+                    brand: 'kia',
+                    region: 'EU',
+                    language: this.options.language ?? DEFAULT_LANGUAGE,
+                    autoLogin: true,
+                };
+                const client = new BlueLinky(config);
+                client.on('ready', (vehicles) => {
+                    this.client = client;
+                    this.indexVehicles(vehicles);
+                    this.log.info(`Logged in to Kia Connect (EU); found ${this.summaries.length} vehicle(s)`);
+                    finish({ success: true });
+                });
+                client.on('error', (error) => {
+                    finish({ success: false, error: errorMessage(error) });
+                });
+            }
+            catch (error) {
+                finish({ success: false, error: errorMessage(error) });
+            }
+        });
+    }
+    async getVehicles() {
+        if (this.summaries.length > 0) {
+            return this.summaries;
+        }
+        if (!this.client) {
+            throw new AuthenticationError('Not logged in to Kia Connect');
+        }
+        const vehicles = await this.client.getVehicles();
+        this.indexVehicles(vehicles);
+        return this.summaries;
+    }
+    async getVehicleStatus(vehicleKey, refresh = false) {
+        const vehicle = this.requireVehicle(vehicleKey);
+        try {
+            const raw = await vehicle.status({ refresh, parsed: false });
+            return mapRawStatus(raw);
+        }
+        catch (error) {
+            throw this.wrapError(error, 'fetch vehicle status');
+        }
+    }
+    async lockDoors(vehicleKey) {
+        const vehicle = this.requireVehicle(vehicleKey);
+        try {
+            return (await vehicle.lock()) ?? '';
+        }
+        catch (error) {
+            throw this.wrapError(error, 'lock doors');
+        }
+    }
+    async unlockDoors(vehicleKey) {
+        const vehicle = this.requireVehicle(vehicleKey);
+        try {
+            return (await vehicle.unlock()) ?? '';
+        }
+        catch (error) {
+            throw this.wrapError(error, 'unlock doors');
+        }
+    }
+    async startClimate(vehicleKey, options) {
+        const vehicle = this.requireVehicle(vehicleKey);
+        const temperature = clamp(options?.temperature ?? DEFAULT_CLIMATE_TEMP_C, MIN_CLIMATE_TEMP_C, MAX_CLIMATE_TEMP_C);
+        try {
+            const result = await vehicle.start({
+                hvac: true,
+                duration: CLIMATE_DURATION_MINUTES,
+                temperature,
+                defrost: options?.defrost ?? false,
+                heatedFeatures: false,
+                unit: 'C',
+            });
+            return result ?? '';
+        }
+        catch (error) {
+            throw this.wrapError(error, 'start climate');
+        }
+    }
+    async stopClimate(vehicleKey) {
+        const vehicle = this.requireVehicle(vehicleKey);
+        try {
+            return (await vehicle.stop()) ?? '';
+        }
+        catch (error) {
+            throw this.wrapError(error, 'stop climate');
+        }
+    }
+    /**
+     * bluelinky resolves command calls once the server accepts them, so there is
+     * no separate transaction to poll. Retained for accessory-layer compatibility.
+     */
+    async waitForAction(_vehicleKey, _actionId) {
+        return true;
+    }
+    indexVehicles(vehicles) {
+        this.vehicles.clear();
+        this.summaries = vehicles.map((vehicle) => {
+            const vin = this.safeCall(() => vehicle.vin());
+            const id = this.safeCall(() => vehicle.id());
+            const nickname = this.safeCall(() => vehicle.nickname());
+            const model = this.safeCall(() => vehicle.name());
+            const key = vin || id;
+            if (key) {
+                this.vehicles.set(key, vehicle);
+            }
+            return {
+                id,
+                vin,
+                key,
+                name: nickname || model || 'Kia Vehicle',
+                model: model || 'Kia',
+            };
+        });
+    }
+    safeCall(fn) {
+        try {
+            return fn() ?? '';
+        }
+        catch {
+            return '';
+        }
+    }
+    requireVehicle(vehicleKey) {
+        const vehicle = this.vehicles.get(vehicleKey);
+        if (!vehicle) {
+            throw new KiaApiError(`Vehicle ${vehicleKey} is not available`);
+        }
+        return vehicle;
+    }
+    wrapError(error, action) {
+        if (error instanceof KiaApiError) {
+            return error;
+        }
+        const message = `Failed to ${action}: ${errorMessage(error)}`;
+        return looksLikeAuthError(message)
+            ? new AuthenticationError(message)
+            : new KiaApiError(message);
+    }
+}
+//# sourceMappingURL=client.js.map