@enyo-energy/energy-app-sdk 0.0.37 → 0.0.39

package/dist/cjs/implementations/modbus/sunspec/sunspec-modbus-client.cjs

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SunspecModbusClient = exports.SunspecModelId = void 0;
+const EnergyAppModbusConnectionHealth_js_1 = require("../EnergyAppModbusConnectionHealth.cjs");
+const EnergyAppModbusFaultTolerantReader_js_1 = require("../EnergyAppModbusFaultTolerantReader.cjs");
+const EnergyAppModbusRegisterMapper_js_1 = require("../EnergyAppModbusRegisterMapper.cjs");
+const EnergyAppModbusDataTypeConverter_js_1 = require("../EnergyAppModbusDataTypeConverter.cjs");
+// Common Sunspec Model IDs
+var SunspecModelId;
+(function (SunspecModelId) {
+    SunspecModelId[SunspecModelId["Common"] = 1] = "Common";
+    SunspecModelId[SunspecModelId["Inverter3Phase"] = 103] = "Inverter3Phase";
+    SunspecModelId[SunspecModelId["InverterSinglePhase"] = 101] = "InverterSinglePhase";
+    SunspecModelId[SunspecModelId["MPPT"] = 160] = "MPPT";
+    SunspecModelId[SunspecModelId["Battery"] = 124] = "Battery";
+    SunspecModelId[SunspecModelId["BatteryBase"] = 802] = "BatteryBase";
+    SunspecModelId[SunspecModelId["BatteryControl"] = 803] = "BatteryControl";
+    SunspecModelId[SunspecModelId["MeterSinglePhase"] = 201] = "MeterSinglePhase";
+    SunspecModelId[SunspecModelId["Meter3Phase"] = 203] = "Meter3Phase";
+    SunspecModelId[SunspecModelId["MeterWye"] = 204] = "MeterWye";
+    SunspecModelId[SunspecModelId["Nameplate"] = 120] = "Nameplate";
+    SunspecModelId[SunspecModelId["Settings"] = 121] = "Settings";
+    SunspecModelId[SunspecModelId["Status"] = 122] = "Status";
+    SunspecModelId[SunspecModelId["Controls"] = 123] = "Controls";
+    SunspecModelId[SunspecModelId["EndMarker"] = 65535] = "EndMarker";
+})(SunspecModelId || (exports.SunspecModelId = SunspecModelId = {}));
+class SunspecModbusClient {
+    energyApp;
+    modbusClient = null;
+    discoveredModels = new Map();
+    scaleFactors = {};
+    connected = false;
+    baseAddress = 40001;
+    connectionHealth;
+    faultTolerantReader = null;
+    registerMapper;
+    dataTypeConverter;
+    constructor(energyApp) {
+        this.energyApp = energyApp;
+        this.connectionHealth = new EnergyAppModbusConnectionHealth_js_1.EnergyAppModbusConnectionHealth();
+        this.registerMapper = new EnergyAppModbusRegisterMapper_js_1.EnergyAppModbusRegisterMapper();
+        this.dataTypeConverter = new EnergyAppModbusDataTypeConverter_js_1.EnergyAppModbusDataTypeConverter();
+    }
+    /**
+     * Connect to Modbus device
+     */
+    async connect(host, port = 502, unitId = 1) {
+        if (this.connected) {
+            await this.disconnect();
+        }
+        this.modbusClient = await this.energyApp.useModbus().connect({
+            host,
+            port,
+            unitId,
+            timeout: 5000
+        });
+        // Create fault-tolerant reader with connection health monitoring
+        if (this.modbusClient) {
+            this.faultTolerantReader = new EnergyAppModbusFaultTolerantReader_js_1.EnergyAppModbusFaultTolerantReader(this.modbusClient, this.connectionHealth);
+        }
+        this.connected = true;
+        this.connectionHealth.recordSuccess();
+        console.log(`Connected to Sunspec device at ${host}:${port} unit ${unitId}`);
+    }
+    /**
+     * Disconnect from Modbus device
+     */
+    async disconnect() {
+        if (this.modbusClient && this.connected) {
+            await this.modbusClient.disconnect();
+            this.modbusClient = null;
+            this.faultTolerantReader = null;
+            this.connected = false;
+            this.discoveredModels.clear();
+            this.scaleFactors = {};
+        }
+    }
+    /**
+     * Discover all available Sunspec models
+     * Scans through the address space starting at 40001
+     */
+    async discoverModels() {
+        if (!this.connected) {
+            throw new Error('Not connected to Modbus device');
+        }
+        this.discoveredModels.clear();
+        let currentAddress = this.baseAddress;
+        const maxAddress = 50000; // Safety limit
+        console.log('Starting Sunspec model discovery...');
+        try {
+            // First, check for Sunspec identifier "SunS" at 40001
+            if (!this.modbusClient) {
+                throw new Error('Modbus client not initialized');
+            }
+            const sunspecId = await this.modbusClient.readRegisterStringValue(40001, 2);
+            if (!sunspecId.includes('SunS')) {
+                console.warn('Device may not be Sunspec compliant - missing SunS identifier');
+            }
+            // Start scanning after the SunS identifier
+            currentAddress = 40003;
+            while (currentAddress < maxAddress) {
+                // Read model ID and length
+                if (!this.modbusClient) {
+                    throw new Error('Modbus client not initialized');
+                }
+                const buffer = await this.modbusClient.readHoldingRegisters(currentAddress, 2);
+                const modelData = [buffer.readUInt16BE(0), buffer.readUInt16BE(2)];
+                if (!modelData || modelData.length < 2) {
+                    console.log(`No data at address ${currentAddress}, ending discovery`);
+                    break;
+                }
+                const modelId = modelData[0];
+                const modelLength = modelData[1];
+                // Check for end marker
+                if (modelId === 0xFFFF || modelId === 65535) {
+                    console.log(`Found end marker at address ${currentAddress}`);
+                    break;
+                }
+                // Store discovered model
+                const model = {
+                    id: modelId,
+                    address: currentAddress,
+                    length: modelLength
+                };
+                this.discoveredModels.set(modelId, model);
+                console.log(`Discovered Model ${modelId} at address ${currentAddress} with length ${modelLength}`);
+                // Jump to next model: current address + 2 (header) + model length
+                currentAddress = currentAddress + 2 + modelLength;
+            }
+        }
+        catch (error) {
+            console.error(`Error during model discovery at address ${currentAddress}: ${error}`);
+        }
+        console.log(`Discovery complete. Found ${this.discoveredModels.size} models`);
+        return this.discoveredModels;
+    }
+    /**
+     * Find a specific model by ID
+     */
+    findModel(modelId) {
+        return this.discoveredModels.get(modelId);
+    }
+    /**
+     * Read a register value and apply scale factor
+     */
+    async readRegisterWithScaleFactor(valueAddress, scaleFactorAddress, quantity = 1) {
+        if (!this.connected) {
+            throw new Error('Not connected to Modbus device');
+        }
+        // Read the raw value
+        if (!this.modbusClient) {
+            throw new Error('Modbus client not initialized');
+        }
+        const buffer = await this.modbusClient.readHoldingRegisters(valueAddress, quantity);
+        let value = buffer.readUInt16BE(0);
+        // Apply scale factor if provided
+        if (scaleFactorAddress) {
+            let scaleFactor = this.scaleFactors[`sf_${scaleFactorAddress}`];
+            if (scaleFactor === undefined) {
+                if (!this.modbusClient) {
+                    throw new Error('Modbus client not initialized');
+                }
+                const sfBuffer = await this.modbusClient.readHoldingRegisters(scaleFactorAddress, 1);
+                // Scale factors are signed int16
+                scaleFactor = this.convertToSigned16(sfBuffer.readUInt16BE(0));
+                this.scaleFactors[`sf_${scaleFactorAddress}`] = scaleFactor;
+            }
+            // Apply scale factor: value * 10^scaleFactor
+            value = value * Math.pow(10, scaleFactor);
+        }
+        return value;
+    }
+    /**
+     * Convert unsigned 16-bit value to signed
+     */
+    convertToSigned16(value) {
+        if (value > 32767) {
+            return value - 65536;
+        }
+        return value;
+    }
+    /**
+     * Helper to read register value(s) using the modbus client with error handling
+     */
+    async readRegisterValue(address, quantity = 1) {
+        if (!this.modbusClient) {
+            throw new Error('Modbus client not initialized');
+        }
+        try {
+            const buffer = await this.modbusClient.readHoldingRegisters(address, quantity);
+            this.connectionHealth.recordSuccess();
+            if (quantity === 1) {
+                return buffer.readUInt16BE(0);
+            }
+            const values = [];
+            for (let i = 0; i < quantity; i++) {
+                values.push(buffer.readUInt16BE(i * 2));
+            }
+            return values;
+        }
+        catch (error) {
+            this.connectionHealth.recordFailure(error);
+            throw error;
+        }
+    }
+    /**
+     * Read inverter data from Model 103 (Three Phase)
+     */
+    async readInverterData() {
+        const model = this.findModel(SunspecModelId.Inverter3Phase);
+        if (!model) {
+            console.log('Inverter model 103 not found, trying single phase model 101');
+            const singlePhaseModel = this.findModel(SunspecModelId.InverterSinglePhase);
+            if (!singlePhaseModel) {
+                console.error('No inverter model found');
+                return null;
+            }
+            return this.readSinglePhaseInverterData(singlePhaseModel);
+        }
+        const baseAddr = model.address + 2; // Skip ID and Length
+        try {
+            // Read all scale factors first (more efficient)
+            const scaleFactors = await this.readInverterScaleFactors(baseAddr);
+            // Read values and apply scale factors
+            const data = {
+                acCurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 2, 1), scaleFactors.A_SF),
+                phaseACurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 3, 1), scaleFactors.A_SF),
+                phaseBCurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 4, 1), scaleFactors.A_SF),
+                phaseCCurrent: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 5, 1), scaleFactors.A_SF),
+                voltageAB: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 7, 1), scaleFactors.V_SF),
+                voltageBC: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 8, 1), scaleFactors.V_SF),
+                voltageCA: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 9, 1), scaleFactors.V_SF),
+                acPower: this.applyScaleFactor(this.convertToSigned16(await this.readRegisterValue(baseAddr + 14, 1)), scaleFactors.W_SF),
+                frequency: this.applyScaleFactor(await this.readRegisterValue(baseAddr + 16, 1), scaleFactors.Hz_SF),
+                dcPower: this.applyScaleFactor(this.convertToSigned16(await this.readRegisterValue(baseAddr + 30, 1)), scaleFactors.DCW_SF),
+                cabinetTemperature: this.applyScaleFactor(this.convertToSigned16(await this.readRegisterValue(baseAddr + 32, 1)), scaleFactors.Tmp_SF),
+                operatingState: await this.readRegisterValue(baseAddr + 37, 1)
+            };
+            // Read AC Energy (32-bit accumulator)
+            const energyRaw = await this.readRegisterValue(baseAddr + 24, 2);
+            data.acEnergy = BigInt((energyRaw[0] << 16) | energyRaw[1]) *
+                BigInt(Math.pow(10, scaleFactors.WH_SF));
+            return data;
+        }
+        catch (error) {
+            console.error(`Error reading inverter data: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Read single phase inverter data (Model 101)
+     */
+    async readSinglePhaseInverterData(model) {
+        // Similar to 3-phase but with fewer phase-specific values
+        // Implementation would be similar but simplified
+        const baseAddr = model.address + 2;
+        try {
+            // Simplified implementation for single phase
+            return {
+                acCurrent: await this.readRegisterWithScaleFactor(baseAddr + 2, baseAddr + 6),
+                acPower: await this.readRegisterWithScaleFactor(baseAddr + 9, baseAddr + 10),
+                frequency: await this.readRegisterWithScaleFactor(baseAddr + 11, baseAddr + 12),
+                dcPower: await this.readRegisterWithScaleFactor(baseAddr + 20, baseAddr + 21),
+                operatingState: await this.readRegisterValue(baseAddr + 24, 1)
+            };
+        }
+        catch (error) {
+            console.error(`Error reading single phase inverter data: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Read inverter scale factors
+     */
+    async readInverterScaleFactors(baseAddr) {
+        return {
+            A_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 6, 1)),
+            V_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 13, 1)),
+            W_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 15, 1)),
+            Hz_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 17, 1)),
+            VA_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 19, 1)),
+            VAr_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 21, 1)),
+            PF_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 23, 1)),
+            WH_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 26, 1)),
+            DCA_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 28, 1)),
+            DCV_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 29, 1)),
+            DCW_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 31, 1)),
+            Tmp_SF: this.convertToSigned16(await this.readRegisterValue(baseAddr + 36, 1))
+        };
+    }
+    /**
+     * Apply scale factor to a value
+     */
+    applyScaleFactor(value, scaleFactor) {
+        return value * Math.pow(10, scaleFactor);
+    }
+    /**
+     * Read MPPT data from Model 160
+     */
+    async readMPPTData(stringId = 1) {
+        const model = this.findModel(SunspecModelId.MPPT);
+        if (!model) {
+            console.log('MPPT model 160 not found');
+            return null;
+        }
+        const baseAddr = model.address + 2;
+        try {
+            // MPPT modules are repeating blocks, calculate offset for specific string
+            const moduleSize = 20; // Typical size of each MPPT module
+            const offset = (stringId - 1) * moduleSize;
+            const moduleAddr = baseAddr + offset;
+            // Read scale factors
+            const DCA_SF = this.convertToSigned16(await this.readRegisterValue(moduleAddr + 3, 1));
+            const DCV_SF = this.convertToSigned16(await this.readRegisterValue(moduleAddr + 5, 1));
+            const DCW_SF = this.convertToSigned16(await this.readRegisterValue(moduleAddr + 7, 1));
+            const Tmp_SF = this.convertToSigned16(await this.readRegisterValue(moduleAddr + 11, 1));
+            const data = {
+                id: stringId,
+                dcCurrent: this.applyScaleFactor(await this.readRegisterValue(moduleAddr + 2, 1), DCA_SF),
+                dcVoltage: this.applyScaleFactor(await this.readRegisterValue(moduleAddr + 4, 1), DCV_SF),
+                dcPower: this.applyScaleFactor(await this.readRegisterValue(moduleAddr + 6, 1), DCW_SF),
+                temperature: this.applyScaleFactor(this.convertToSigned16(await this.readRegisterValue(moduleAddr + 10, 1)), Tmp_SF),
+                operatingState: await this.readRegisterValue(moduleAddr + 12, 1),
+                events: await this.readRegisterValue(moduleAddr + 13, 1)
+            };
+            // Read DC Energy (32-bit)
+            const energyRaw = await this.readRegisterValue(moduleAddr + 8, 2);
+            data.dcEnergy = BigInt((energyRaw[0] << 16) | energyRaw[1]);
+            return data;
+        }
+        catch (error) {
+            console.error(`Error reading MPPT data for string ${stringId}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Read all available MPPT strings
+     */
+    async readAllMPPTData() {
+        const mpptData = [];
+        // Try to read up to 4 MPPT strings (typical maximum)
+        for (let i = 1; i <= 4; i++) {
+            const data = await this.readMPPTData(i);
+            if (data && data.dcCurrent !== undefined && data.dcCurrent > 0) {
+                mpptData.push(data);
+            }
+        }
+        return mpptData;
+    }
+    /**
+     * Read meter data (Model 203 for 3-phase)
+     */
+    async readMeterData() {
+        let model = this.findModel(SunspecModelId.Meter3Phase);
+        if (!model) {
+            model = this.findModel(SunspecModelId.MeterWye);
+        }
+        if (!model) {
+            model = this.findModel(SunspecModelId.MeterSinglePhase);
+        }
+        if (!model) {
+            console.log('No meter model found');
+            return null;
+        }
+        const baseAddr = model.address + 2;
+        try {
+            // This is a simplified implementation
+            // Actual register offsets depend on specific meter model
+            return {
+                totalPower: await this.readRegisterWithScaleFactor(baseAddr + 10, baseAddr + 11),
+                frequency: await this.readRegisterWithScaleFactor(baseAddr + 20, baseAddr + 21)
+            };
+        }
+        catch (error) {
+            console.error(`Error reading meter data: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Read common block data (Model 1)
+     */
+    async readCommonBlock() {
+        const model = this.findModel(SunspecModelId.Common);
+        if (!model) {
+            console.error('Common block model not found');
+            return null;
+        }
+        const baseAddr = model.address + 2;
+        try {
+            if (!this.modbusClient) {
+                throw new Error('Modbus client not initialized');
+            }
+            const manufacturer = await this.modbusClient.readRegisterStringValue(baseAddr, 16);
+            const modelName = await this.modbusClient.readRegisterStringValue(baseAddr + 16, 16);
+            const serialNumber = await this.modbusClient.readRegisterStringValue(baseAddr + 48, 16);
+            return {
+                manufacturer: manufacturer.replace(/\u0000/gmi, '').trim(),
+                model: modelName.replace(/\u0000/gmi, '').trim(),
+                serialNumber: serialNumber.replace(/\u0000/gmi, '').trim()
+            };
+        }
+        catch (error) {
+            console.error(`Error reading common block: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Get serial number from device
+     */
+    async getSerialNumber() {
+        const commonData = await this.readCommonBlock();
+        return commonData?.serialNumber;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Check if connection is healthy
+     */
+    isHealthy() {
+        return this.connected && this.connectionHealth.isHealthy();
+    }
+    /**
+     * Get connection health details
+     */
+    getConnectionHealth() {
+        return this.connectionHealth;
+    }
+}
+exports.SunspecModbusClient = SunspecModbusClient;

package/dist/cjs/implementations/modbus/sunspec/sunspec-modbus-client.d.cts

@@ -0,0 +1,171 @@
+import type { IConnectionHealth } from "../interfaces.cjs";
+import { EnergyApp } from "../../../index.cjs";
+export declare enum SunspecModelId {
+    Common = 1,
+    Inverter3Phase = 103,
+    InverterSinglePhase = 101,
+    MPPT = 160,
+    Battery = 124,
+    BatteryBase = 802,
+    BatteryControl = 803,
+    MeterSinglePhase = 201,
+    Meter3Phase = 203,
+    MeterWye = 204,
+    Nameplate = 120,
+    Settings = 121,
+    Status = 122,
+    Controls = 123,
+    EndMarker = 65535
+}
+interface SunspecModel {
+    id: number;
+    address: number;
+    length: number;
+}
+export interface SunspecInverterData {
+    acCurrent?: number;
+    phaseACurrent?: number;
+    phaseBCurrent?: number;
+    phaseCCurrent?: number;
+    voltageAB?: number;
+    voltageBC?: number;
+    voltageCA?: number;
+    voltageAN?: number;
+    voltageBN?: number;
+    voltageCN?: number;
+    acPower?: number;
+    frequency?: number;
+    apparentPower?: number;
+    reactivePower?: number;
+    powerFactor?: number;
+    acEnergy?: bigint;
+    dcCurrent?: number;
+    dcVoltage?: number;
+    dcPower?: number;
+    cabinetTemperature?: number;
+    operatingState?: number;
+    events?: number;
+}
+export interface SunspecMPPTData {
+    id: number;
+    dcCurrent?: number;
+    dcVoltage?: number;
+    dcPower?: number;
+    dcEnergy?: bigint;
+    temperature?: number;
+    operatingState?: number;
+    events?: number;
+}
+export interface SunspecBatteryData {
+    soc?: number;
+    soh?: number;
+    chargePower?: number;
+    dischargePower?: number;
+    voltage?: number;
+    current?: number;
+    temperature?: number;
+    status?: number;
+}
+export interface SunspecMeterData {
+    totalPower?: number;
+    phaseAPower?: number;
+    phaseBPower?: number;
+    phaseCPower?: number;
+    totalEnergy?: bigint;
+    exportedEnergy?: bigint;
+    importedEnergy?: bigint;
+    voltage?: number;
+    current?: number;
+    frequency?: number;
+}
+export declare class SunspecModbusClient {
+    private energyApp;
+    private modbusClient;
+    private discoveredModels;
+    private scaleFactors;
+    private connected;
+    private baseAddress;
+    private connectionHealth;
+    private faultTolerantReader;
+    private registerMapper;
+    private dataTypeConverter;
+    constructor(energyApp: EnergyApp);
+    /**
+     * Connect to Modbus device
+     */
+    connect(host: string, port?: number, unitId?: number): Promise<void>;
+    /**
+     * Disconnect from Modbus device
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Discover all available Sunspec models
+     * Scans through the address space starting at 40001
+     */
+    discoverModels(): Promise<Map<number, SunspecModel>>;
+    /**
+     * Find a specific model by ID
+     */
+    findModel(modelId: number): SunspecModel | undefined;
+    /**
+     * Read a register value and apply scale factor
+     */
+    readRegisterWithScaleFactor(valueAddress: number, scaleFactorAddress?: number, quantity?: number): Promise<number>;
+    /**
+     * Convert unsigned 16-bit value to signed
+     */
+    private convertToSigned16;
+    /**
+     * Helper to read register value(s) using the modbus client with error handling
+     */
+    private readRegisterValue;
+    /**
+     * Read inverter data from Model 103 (Three Phase)
+     */
+    readInverterData(): Promise<SunspecInverterData | null>;
+    /**
+     * Read single phase inverter data (Model 101)
+     */
+    private readSinglePhaseInverterData;
+    /**
+     * Read inverter scale factors
+     */
+    private readInverterScaleFactors;
+    /**
+     * Apply scale factor to a value
+     */
+    private applyScaleFactor;
+    /**
+     * Read MPPT data from Model 160
+     */
+    readMPPTData(stringId?: number): Promise<SunspecMPPTData | null>;
+    /**
+     * Read all available MPPT strings
+     */
+    readAllMPPTData(): Promise<SunspecMPPTData[]>;
+    /**
+     * Read meter data (Model 203 for 3-phase)
+     */
+    readMeterData(): Promise<SunspecMeterData | null>;
+    /**
+     * Read common block data (Model 1)
+     */
+    readCommonBlock(): Promise<any>;
+    /**
+     * Get serial number from device
+     */
+    getSerialNumber(): Promise<string | undefined>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Check if connection is healthy
+     */
+    isHealthy(): boolean;
+    /**
+     * Get connection health details
+     */
+    getConnectionHealth(): IConnectionHealth;
+}
+export {};

package/dist/cjs/index.cjs

@@ -17,9 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnergyApp = void 0;
 const version_js_1 = require("./version.cjs");
 __exportStar(require("./energy-app-package-definition.cjs"), exports);
-__exportStar(require("./implementations/modbus/EnergyAppModbusBattery.cjs"), exports);
-__exportStar(require("./implementations/modbus/EnergyAppModbusMeter.cjs"), exports);
-__exportStar(require("./implementations/modbus/EnergyAppModbusInverter.cjs"), exports);
 __exportStar(require("./version.cjs"), exports);
 __exportStar(require("./implementations/ocpp/ocpp16.cjs"), exports);
 __exportStar(require("./implementations/ocpp/ocpp201.cjs"), exports);
@@ -29,6 +26,8 @@ __exportStar(require("./types/enyo-settings.cjs"), exports);
 __exportStar(require("./types/enyo-energy-tariff.cjs"), exports);
 __exportStar(require("./types/enyo-electricity-prices.cjs"), exports);
 __exportStar(require("./types/enyo-notification.cjs"), exports);
+__exportStar(require("./implementations/appliances/appliance-manager.cjs"), exports);
+__exportStar(require("./implementations/appliances/identifier-strategies.cjs"), exports);
 class EnergyApp {
     energyAppSdk;
     constructor() {

package/dist/cjs/index.d.cts

@@ -14,9 +14,6 @@ import { EnergyAppSettings } from "./packages/energy-app-settings.cjs";
 import { EnergyAppElectricityPrices } from "./packages/energy-app-electricity-prices.cjs";
 import { EnergyAppNotification } from "./packages/energy-app-notification.cjs";
 export * from './energy-app-package-definition.cjs';
-export * from './implementations/modbus/EnergyAppModbusBattery.cjs';
-export * from './implementations/modbus/EnergyAppModbusMeter.cjs';
-export * from './implementations/modbus/EnergyAppModbusInverter.cjs';
 export * from './version.cjs';
 export * from './implementations/ocpp/ocpp16.cjs';
 export * from './implementations/ocpp/ocpp201.cjs';
@@ -26,6 +23,8 @@ export * from './types/enyo-settings.cjs';
 export * from './types/enyo-energy-tariff.cjs';
 export * from './types/enyo-electricity-prices.cjs';
 export * from './types/enyo-notification.cjs';
+export * from './implementations/appliances/appliance-manager.cjs';
+export * from './implementations/appliances/identifier-strategies.cjs';
 export declare class EnergyApp implements EnyoEnergyAppSdk {
     private readonly energyAppSdk;
     constructor();

package/dist/cjs/types/enyo-data-bus-value.d.cts

@@ -109,6 +109,7 @@ export declare enum EnyoDataBusMessageEnum {
     AggregatedStateUpdateV1 = "AggregatedStateUpdateV1",
     EnergyTariffUpdateV1 = "EnergyTariffUpdateV1"
 }
+export type EnyoDataBusMessageResolution = '10s' | '30s' | '1m' | '15m' | '1h' | '1d' | 'dynamic';
 export interface EnyoDataBusMessage {
     id: string;
     message: EnyoDataBusMessageEnum;
@@ -118,7 +119,7 @@ export interface EnyoDataBusMessage {
     clockId?: string;
     timestampIso: string;
     /** If you just forward events that occur, use dynamic as resolution */
-    resolution?: '10s' | '30s' | '1m' | '15m' | '1h' | '1d' | 'dynamic';
+    resolution?: EnyoDataBusMessageResolution;
     data: object;
 }
 export interface EnyoDataBusMessageAnswer extends EnyoDataBusMessage {

package/dist/cjs/version.cjs

@@ -9,7 +9,7 @@ exports.getSdkVersion = getSdkVersion;
 /**
  * Current version of the enyo Energy App SDK.
  */
-exports.SDK_VERSION = '0.0.37';
+exports.SDK_VERSION = '0.0.39';
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/dist/cjs/version.d.cts

@@ -5,7 +5,7 @@
 /**
  * Current version of the enyo Energy App SDK.
  */
-export declare const SDK_VERSION = "0.0.37";
+export declare const SDK_VERSION = "0.0.39";
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK