myenergi-api 2.9.0 → 2.11.0

package/README.md

@@ -134,6 +134,59 @@ console.log(result);
 ```
 
 
+### Libbi charge from grid (myenergi account)
+Charge from grid is not available through the hub serial and API key. It uses the myenergi account API, which needs the email and password of your myenergi account. Unlike `MyEnergi`, the methods of `MyEnergiAccount` throw a `MyEnergiAccountError` when a request fails.
+
+The Libbi only charges from the grid up to its charge target, and only during the cheap periods of the tariff configured in the myenergi app.
+```typescript
+const account = new MyEnergiAccount("me@example.com", "!3uper3ecretPassw0rd");
+const sno = '1234567';
+
+const enabled: boolean = await account.getLibbiChargeFromGrid(sno);
+await account.setLibbiChargeFromGrid(sno, true);
+
+// Charge target in Wh
+const setup: LibbiChargeSetup = await account.getLibbiChargeSetup(sno);
+await account.setLibbiChargeTarget(sno, 4600);
+```
+
+### Other myenergi account functions
+`MyEnergiAccount` also covers the rest of the known account API. Hubs and devices are identified by their account id here, not by serial number.
+```typescript
+const hubs = await account.getHubs();                     // includes serial number and API key per hub
+const hubId = hubs[0].hubId;
+const zappi = await account.getDevice('1234567');         // look up a device's account id by serial number
+const locations = await account.getLocations();           // sites, with address and energy setup
+const vehicles = await account.getVehicles();             // vehicle profiles
+const schedules = await account.getChargeSchedules();     // all charge schedules, per hub and device
+const history = await account.getHubHourlyHistory(hubId, new Date());
+const tariff = await account.getDualTariff(hubId);
+await account.saveDualTariff(tariff);                     // overwrites the tariff set in the myenergi app
+```
+`saveDualTariff` has not been verified against the live API.
+
+For a location you were invited to as a guest, set `account.invitationId` to the `invitationData.invitationId` of that location.
+
+### Zappi single charge (myenergi account)
+A single charge is a one-off, date-specific charge: myenergi picks the cheapest times in the window from the tariff on the account. It is not the same as a smart boost. A Zappi that does not support schedules is not listed by `getChargeSchedules`.
+```typescript
+const zappi = await account.getDevice('1234567');
+const vehicles = await account.getVehicles();
+
+// Adds to the single charges the Zappi already has
+await account.addZappiSingleCharge(zappi.id, {
+    name: 'Homey',
+    vehicleId: vehicles[0].id,
+    kWh: 10,
+    date: new Date(2026, 9, 12),
+    fromTime: '22:00',
+    toTime: '07:00',
+});
+
+await account.clearZappiSingleCharges(zappi.id);
+```
+The API only replaces the complete list of a schedule type; `saveChargeSchedules` gives direct access to that call.
+
 ## From myenergi documentation
 <a name="myenergi_documentation"></a>
 <a name="charge_mode"></a>

package/dist/src/MyEnergiAccount.d.ts

@@ -0,0 +1,45 @@
+import { AccountDevice, AccountHub, AccountHubsAndDevices, AccountLocation, AccountVehicle, DeviceChargeSchedules, DualTariff, HubChargeSchedules, ZappiSingleCharge } from "./models/Account";
+import { HistoryRecord } from "./models/HistoryRecord";
+import { LibbiChargeSetup } from "./models/LibbiChargeSetup";
+export declare class MyEnergiAccountError extends Error {
+    statusCode?: number;
+    authFailed: boolean;
+    constructor(message: string, statusCode?: number, authFailed?: boolean);
+}
+export declare class MyEnergiAccount {
+    private _config;
+    invitationId?: string;
+    private _accessToken?;
+    private _refreshToken?;
+    private _expiresAt;
+    private _signingIn?;
+    constructor(email: string, password: string, accountBaseUrl?: string, authUrl?: string);
+    login(): Promise<void>;
+    getLibbiChargeFromGrid(serialNo: string): Promise<boolean>;
+    setLibbiChargeFromGrid(serialNo: string, chargeFromGrid: boolean): Promise<void>;
+    getLibbiChargeSetup(serialNo: string): Promise<LibbiChargeSetup>;
+    setLibbiChargeTarget(serialNo: string, targetEnergyWh: number): Promise<void>;
+    getHubs(): Promise<AccountHub[]>;
+    getHubsAndDevices(): Promise<AccountHubsAndDevices>;
+    getDevice(serialNo: string): Promise<AccountDevice | null>;
+    getLocations(): Promise<AccountLocation[]>;
+    getVehicles(): Promise<AccountVehicle[]>;
+    getChargeSchedules(): Promise<HubChargeSchedules[]>;
+    getDeviceChargeSchedules(deviceId: string): Promise<DeviceChargeSchedules | null>;
+    hasTariffPrices(hubId: string): Promise<boolean>;
+    saveChargeSchedules(deviceId: string, scheduleType: string, chargeSchedules: any[], isActive?: boolean): Promise<unknown>;
+    addZappiSingleCharge(deviceId: string, charge: ZappiSingleCharge): Promise<unknown>;
+    clearZappiSingleCharges(deviceId: string): Promise<unknown>;
+    getDualTariff(hubId: string): Promise<DualTariff[]>;
+    saveDualTariff(tariffs: DualTariff[]): Promise<unknown>;
+    getHubHourlyHistory(hubId: string, day: Date, hours?: number): Promise<{
+        [key: string]: HistoryRecord[];
+    }>;
+    private toSingleChargeRequest;
+    private formatDay;
+    private call;
+    private getAccessToken;
+    private renewAccessToken;
+    private authenticate;
+    private request;
+}

package/dist/src/MyEnergiAccount.js

@@ -0,0 +1,333 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyEnergiAccount = exports.MyEnergiAccountError = void 0;
+const https = __importStar(require("https"));
+class MyEnergiAccountError extends Error {
+    constructor(message, statusCode, authFailed = false) {
+        super(message);
+        this.name = "MyEnergiAccountError";
+        this.statusCode = statusCode;
+        this.authFailed = authFailed;
+    }
+}
+exports.MyEnergiAccountError = MyEnergiAccountError;
+class MyEnergiAccount {
+    constructor(email, password, accountBaseUrl, authUrl) {
+        this._config = {
+            email: "",
+            password: "",
+            base_url: "https://myaccount.myenergi.com",
+            auth_url: "https://cognito-idp.eu-west-2.amazonaws.com/",
+            client_id: "2fup0dhufn5vurmprjkj599041",
+            libbi_mode_url: "/api/AccountAccess/LibbiMode",
+            account_access_url: "/api/AccountAccess/",
+            hubs_url: "/api/AccountAccess/Hubs",
+            hubs_and_devices_url: "/api/Product/UserHubsAndDevices",
+            location_url: "/api/Location",
+            vehicles_url: "/api/Vehicle/UserVehicles",
+            schedules_url: "/api/ChargeSchedules/GetAllSchedules",
+            display_schedules_url: "/api/ChargeSchedules/DisplaySchedules",
+            save_schedules_url: "/api/ChargeSchedules/SaveSchedules",
+            get_tariff_url: "/api/EnergySetup/GetDualTariffEnergyPrices",
+            save_tariff_url: "/api/EnergySetup/SaveDualTariffEnergyPrices",
+            hourly_data_url: "/api/Graphs/DevicesOfHubDataHourly",
+        };
+        this._expiresAt = 0;
+        this._config.email = email;
+        this._config.password = password;
+        if (accountBaseUrl)
+            this._config.base_url = accountBaseUrl;
+        if (authUrl)
+            this._config.auth_url = authUrl;
+    }
+    login() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.authenticate("USER_PASSWORD_AUTH", { USERNAME: this._config.email, PASSWORD: this._config.password });
+        });
+    }
+    getLibbiChargeFromGrid(serialNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = yield this.call("GET", `${this._config.libbi_mode_url}?serialNo=${encodeURIComponent(serialNo)}`);
+            return !!(content && content[serialNo]);
+        });
+    }
+    setLibbiChargeFromGrid(serialNo, chargeFromGrid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.call("PUT", `${this._config.libbi_mode_url}?chargeFromGrid=${chargeFromGrid}&serialNo=${encodeURIComponent(serialNo)}`);
+        });
+    }
+    getLibbiChargeSetup(serialNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = yield this.call("GET", `${this._config.account_access_url}${encodeURIComponent(serialNo)}/LibbiChargeSetup`);
+            return Object.assign({}, content);
+        });
+    }
+    setLibbiChargeTarget(serialNo, targetEnergyWh) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.call("PUT", `${this._config.account_access_url}${encodeURIComponent(serialNo)}/TargetEnergy?targetEnergy=${Math.round(targetEnergyWh)}`);
+        });
+    }
+    getHubs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = yield this.call("GET", this._config.hubs_url);
+            return (content && content.hubs) || [];
+        });
+    }
+    getHubsAndDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign({ hubs: [], devices: [], offlineDevices: [] }, yield this.call("GET", this._config.hubs_and_devices_url));
+        });
+    }
+    getDevice(serialNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { devices } = yield this.getHubsAndDevices();
+            const found = devices.find((d) => d.device && d.device.serialNumber == serialNo);
+            return found ? found.device : null;
+        });
+    }
+    getLocations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.call("GET", this._config.location_url)) || [];
+        });
+    }
+    getVehicles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.call("GET", this._config.vehicles_url)) || [];
+        });
+    }
+    getChargeSchedules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.call("GET", this._config.schedules_url)) || [];
+        });
+    }
+    getDeviceChargeSchedules(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const hub of yield this.getChargeSchedules()) {
+                const device = (hub.devices || []).find((d) => d.deviceId == deviceId);
+                if (device)
+                    return device;
+            }
+            return null;
+        });
+    }
+    hasTariffPrices(hubId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = yield this.call("GET", `${this._config.display_schedules_url}?hubId=${encodeURIComponent(hubId)}`);
+            return !!(content && content.hasTariffResponse);
+        });
+    }
+    saveChargeSchedules(deviceId, scheduleType, chargeSchedules, isActive = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.call("POST", this._config.save_schedules_url, { chargeSchedules, deviceId, isActive, scheduleType });
+        });
+    }
+    addZappiSingleCharge(deviceId, charge) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [device, vehicles] = yield Promise.all([this.getDeviceChargeSchedules(deviceId), this.getVehicles()]);
+            if (!device)
+                throw new MyEnergiAccountError("The device does not support charge schedules.");
+            const existing = (device.singleCharges || []).map((c) => this.toSingleChargeRequest(c, vehicles));
+            const added = this.toSingleChargeRequest({
+                scheduleType: "Single",
+                scheduleNickName: charge.name,
+                chargingOutputName: charge.vehicleId,
+                chargeAmountMinutes: 0,
+                chargeAmountKWh: charge.kWh,
+                fromTime: charge.fromTime,
+                toTime: charge.toTime,
+                singleChargeDay: typeof charge.date === "string" ? charge.date : this.formatDay(charge.date),
+            }, vehicles);
+            return this.saveChargeSchedules(deviceId, "Single", [...existing, added]);
+        });
+    }
+    clearZappiSingleCharges(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.saveChargeSchedules(deviceId, "Single", []);
+        });
+    }
+    getDualTariff(hubId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.call("GET", `${this._config.get_tariff_url}?hubId=${encodeURIComponent(hubId)}`)) || [];
+        });
+    }
+    saveDualTariff(tariffs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = tariffs.map((t) => ({
+                days: t.days,
+                energySetupId: t.energySetupId,
+                tariffs: t.tariffs.map((b) => ({ fromMinutes: b.fromMinutes, price: b.price, toMinutes: b.toMinutes })),
+            }));
+            return this.call("POST", this._config.save_tariff_url, body);
+        });
+    }
+    getHubHourlyHistory(hubId, day, hours = 24) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const start = Date.UTC(day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate());
+            const content = yield this.call("POST", this._config.hourly_data_url, { hubId, dayTimestampsUtc: [start], duration: hours });
+            return content || {};
+        });
+    }
+    toSingleChargeRequest(charge, vehicles) {
+        const vehicle = vehicles.find((v) => v.id == charge.chargingOutputName);
+        if (!vehicle)
+            throw new MyEnergiAccountError(`Unknown vehicle profile: ${charge.chargingOutputName}`);
+        const day = `${charge.singleChargeDay || ""}`;
+        const usDate = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(day);
+        const request = {
+            scheduleNickName: charge.scheduleNickName,
+            vehicle: { id: vehicle.id, manufacturer: vehicle.manufacturer, model: vehicle.model, batterySize: vehicle.batterySize, chargeRate: vehicle.chargeRate },
+            power: charge.chargeAmountKWh,
+            singleChargeDay: usDate ? `${usDate[2]}-${usDate[1]}-${usDate[3]}` : day,
+            fromTime: charge.fromTime,
+            toTime: charge.toTime,
+            chargeAmountMinutes: Math.round(charge.chargeAmountKWh / vehicle.chargeRate * 60),
+            chargingOutputName: vehicle.id,
+            scheduleType: "Single",
+            chargeAmountKWh: charge.chargeAmountKWh,
+        };
+        if (charge.id)
+            request.id = charge.id;
+        return request;
+    }
+    formatDay(date) {
+        const pad = (n) => `${n}`.padStart(2, "0");
+        return `${pad(date.getDate())}-${pad(date.getMonth() + 1)}-${date.getFullYear()}`;
+    }
+    call(method, path, body, retry = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.getAccessToken();
+            const url = new URL(path, this._config.base_url);
+            if (this.invitationId)
+                url.searchParams.set("invitationId", this.invitationId);
+            const headers = { Authorization: `Bearer ${token}`, Accept: "application/json" };
+            if (body !== undefined)
+                headers["Content-Type"] = "application/json";
+            const res = yield this.request(method, url, headers, body !== undefined ? JSON.stringify(body) : undefined);
+            if (res.statusCode == 401 && retry) {
+                this._accessToken = undefined;
+                this._refreshToken = undefined;
+                return this.call(method, path, body, false);
+            }
+            let jsonData = {};
+            try {
+                jsonData = JSON.parse(res.body);
+            }
+            catch (error) {
+            }
+            if (res.statusCode < 200 || res.statusCode >= 300 || jsonData.status !== true) {
+                throw new MyEnergiAccountError(jsonData.message || `Request failed with status code ${res.statusCode}`, res.statusCode, res.statusCode == 401);
+            }
+            return jsonData.content;
+        });
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._accessToken || Date.now() >= this._expiresAt) {
+                if (!this._signingIn) {
+                    this._signingIn = this.renewAccessToken().then(() => { this._signingIn = undefined; }, (error) => { this._signingIn = undefined; throw error; });
+                }
+                yield this._signingIn;
+            }
+            return this._accessToken;
+        });
+    }
+    renewAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._refreshToken) {
+                try {
+                    yield this.authenticate("REFRESH_TOKEN_AUTH", { REFRESH_TOKEN: this._refreshToken });
+                    return;
+                }
+                catch (error) {
+                    this._refreshToken = undefined;
+                }
+            }
+            yield this.login();
+        });
+    }
+    authenticate(authFlow, authParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.request("POST", new URL(this._config.auth_url), {
+                "Content-Type": "application/x-amz-json-1.1",
+                "X-Amz-Target": "AWSCognitoIdentityProviderService.InitiateAuth",
+            }, JSON.stringify({ AuthFlow: authFlow, AuthParameters: authParameters, ClientId: this._config.client_id }));
+            let jsonData = {};
+            try {
+                jsonData = JSON.parse(res.body);
+            }
+            catch (error) {
+            }
+            const result = jsonData.AuthenticationResult;
+            if (res.statusCode != 200 || !result || !result.AccessToken) {
+                const authFailed = jsonData.__type === "NotAuthorizedException" || jsonData.__type === "UserNotFoundException";
+                const message = jsonData.ChallengeName
+                    ? `Unsupported sign in challenge: ${jsonData.ChallengeName}`
+                    : jsonData.message || `Sign in failed with status code ${res.statusCode}`;
+                throw new MyEnergiAccountError(message, res.statusCode, authFailed);
+            }
+            this._accessToken = result.AccessToken;
+            this._expiresAt = Date.now() + ((result.ExpiresIn || 3600) - 60) * 1000;
+            if (result.RefreshToken)
+                this._refreshToken = result.RefreshToken;
+        });
+    }
+    request(method, url, headers, data) {
+        return new Promise((resolve, reject) => {
+            if (data !== undefined)
+                headers["Content-Length"] = `${Buffer.byteLength(data)}`;
+            const req = https.request(url, { method, headers }, (res) => {
+                let resData = "";
+                res.setEncoding("utf8");
+                res.on("data", (chunk) => {
+                    resData += chunk;
+                });
+                res.on("end", () => {
+                    resolve({ statusCode: res.statusCode || 0, body: resData });
+                });
+            });
+            req.setTimeout(20000, () => {
+                req.destroy(new Error("Request timed out"));
+            });
+            req.on("error", (e) => {
+                reject(e);
+            });
+            if (data !== undefined) {
+                req.write(data);
+            }
+            req.end();
+        });
+    }
+}
+exports.MyEnergiAccount = MyEnergiAccount;

package/dist/src/index.d.ts

@@ -1,8 +1,11 @@
+import { AccountDevice, AccountHub, AccountHubsAndDevices, AccountLocation, AccountVehicle, ChargeSchedule, DeviceChargeSchedules, DualTariff, HubChargeSchedules, TariffBand, ZappiSingleCharge } from "./models/Account";
 import { Eddi } from "./models/Eddi";
 import { Harvi } from "./models/Harvi";
 import { HistoryRecord } from "./models/HistoryRecord";
 import { Libbi } from "./models/Libbi";
+import { LibbiChargeSetup } from "./models/LibbiChargeSetup";
 import { EddiBoost, EddiHeaterStatus, EddiMode, LibbiMode, ZappiBoostMode, ZappiChargeMode, ZappiPhaseSetting, ZappiStatus } from "./models/Types";
 import { Zappi } from "./models/Zappi";
 import { MyEnergi } from "./MyEnergi";
-export { MyEnergi, Eddi, Zappi, Harvi, Libbi, HistoryRecord, EddiBoost, EddiMode, EddiHeaterStatus, LibbiMode, ZappiBoostMode, ZappiChargeMode, ZappiPhaseSetting, ZappiStatus };
+import { MyEnergiAccount, MyEnergiAccountError } from "./MyEnergiAccount";
+export { MyEnergi, MyEnergiAccount, MyEnergiAccountError, Eddi, Zappi, Harvi, Libbi, LibbiChargeSetup, AccountDevice, AccountHub, AccountHubsAndDevices, AccountLocation, AccountVehicle, ChargeSchedule, DeviceChargeSchedules, DualTariff, HubChargeSchedules, TariffBand, ZappiSingleCharge, HistoryRecord, EddiBoost, EddiMode, EddiHeaterStatus, LibbiMode, ZappiBoostMode, ZappiChargeMode, ZappiPhaseSetting, ZappiStatus };

package/dist/src/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZappiStatus = exports.ZappiPhaseSetting = exports.ZappiChargeMode = exports.ZappiBoostMode = exports.LibbiMode = exports.EddiHeaterStatus = exports.EddiMode = exports.EddiBoost = exports.MyEnergi = void 0;
+exports.ZappiStatus = exports.ZappiPhaseSetting = exports.ZappiChargeMode = exports.ZappiBoostMode = exports.LibbiMode = exports.EddiHeaterStatus = exports.EddiMode = exports.EddiBoost = exports.MyEnergiAccountError = exports.MyEnergiAccount = exports.MyEnergi = void 0;
 const Types_1 = require("./models/Types");
 Object.defineProperty(exports, "EddiBoost", { enumerable: true, get: function () { return Types_1.EddiBoost; } });
 Object.defineProperty(exports, "EddiHeaterStatus", { enumerable: true, get: function () { return Types_1.EddiHeaterStatus; } });
@@ -12,3 +12,6 @@ Object.defineProperty(exports, "ZappiPhaseSetting", { enumerable: true, get: fun
 Object.defineProperty(exports, "ZappiStatus", { enumerable: true, get: function () { return Types_1.ZappiStatus; } });
 const MyEnergi_1 = require("./MyEnergi");
 Object.defineProperty(exports, "MyEnergi", { enumerable: true, get: function () { return MyEnergi_1.MyEnergi; } });
+const MyEnergiAccount_1 = require("./MyEnergiAccount");
+Object.defineProperty(exports, "MyEnergiAccount", { enumerable: true, get: function () { return MyEnergiAccount_1.MyEnergiAccount; } });
+Object.defineProperty(exports, "MyEnergiAccountError", { enumerable: true, get: function () { return MyEnergiAccount_1.MyEnergiAccountError; } });

package/dist/src/models/Account.d.ts

@@ -0,0 +1,125 @@
+export interface AccountHub {
+    hubId: string;
+    hubName: string;
+    serialNo: string;
+    hubPassword: string;
+    locationId: string;
+    locationName: string;
+    isVHub: boolean;
+    server: string;
+    devices: string[];
+}
+export interface AccountDevice {
+    id: string;
+    deviceName: string;
+    deviceType: string;
+    serialNumber: string;
+    firmware: string;
+    status: number;
+    locationId?: string;
+}
+export interface AccountHubsAndDevices {
+    hubs: {
+        hub: {
+            id: string;
+            serialNo: string;
+            nickName: string;
+            firmware: string;
+            isVHub: boolean;
+        };
+        deviceIds: string[];
+        locationId: string;
+    }[];
+    devices: {
+        device: AccountDevice;
+        locationId: string;
+        isVHub: boolean;
+    }[];
+    offlineDevices: unknown[];
+}
+export interface AccountLocation {
+    address: {
+        id: string;
+        siteName: string;
+        countryCode: string;
+        currency: string;
+        [key: string]: unknown;
+    };
+    energySetup: {
+        id: string;
+        energyProvider: string;
+        energyTariff: string;
+        tariffFriendlyName: string;
+        isEconomy: boolean;
+        isActive: boolean;
+        [key: string]: unknown;
+    };
+    isGuestLocation: boolean;
+    invitationData?: {
+        invitationId: string;
+        [key: string]: unknown;
+    };
+    ownerEmail: string;
+}
+export interface AccountVehicle {
+    id: string;
+    manufacturer: string;
+    model: string;
+    batterySize: number;
+    chargeRate: number;
+    manufacturingYear?: number;
+    ownership?: number;
+}
+export interface ChargeSchedule {
+    id?: string;
+    scheduleType: string;
+    scheduleNickName: string;
+    chargingOutputName: string;
+    chargeAmountMinutes: number;
+    chargeAmountKWh: number;
+    fromTime: string;
+    toTime: string;
+    singleChargeDay?: string;
+    isActive?: boolean;
+    [key: string]: unknown;
+}
+export interface DeviceChargeSchedules {
+    deviceId: string;
+    deviceName: string;
+    deviceType: string;
+    firmware: string;
+    scheduleCharges: ChargeSchedule[];
+    scheduleChargesActive: boolean;
+    budgetCharges: ChargeSchedule[];
+    budgetChargesActive: boolean;
+    singleCharges: ChargeSchedule[];
+    singleChargesActive: boolean;
+}
+export interface HubChargeSchedules {
+    hubId: string;
+    hubNickName: string;
+    energySetupProvider: string;
+    energySetupTarrif: string;
+    isEconomy: boolean;
+    isGuestUser: boolean;
+    devices: DeviceChargeSchedules[];
+}
+export interface ZappiSingleCharge {
+    name: string;
+    vehicleId: string;
+    kWh: number;
+    date: Date | string;
+    fromTime: string;
+    toTime: string;
+}
+export interface TariffBand {
+    id?: string;
+    fromMinutes: number;
+    toMinutes: number;
+    price: number;
+}
+export interface DualTariff {
+    energySetupId: string;
+    days: number[];
+    tariffs: TariffBand[];
+}

package/dist/src/models/Account.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/LibbiChargeSetup.d.ts

@@ -0,0 +1,5 @@
+export interface LibbiChargeSetup {
+    deviceSerial: string;
+    chargeFromGrid: boolean;
+    energyTarget: number;
+}

package/dist/src/models/LibbiChargeSetup.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myenergi-api",
-    "version": "2.9.0",
+    "version": "2.11.0",
     "description": "NodeJS implementation of MyEnergi API for controlling Zappi, Eddi and other MyEnergi products",
     "main": "dist/src/index.js",
     "types": "dist/src/index.d.ts",