@enyo-energy/energy-app-sdk 0.0.34

package/dist/implementations/modbus/EnergyAppModbusMeter.js

@@ -0,0 +1,195 @@
+import { randomUUID } from "node:crypto";
+import { EnyoApplianceConnectionType, EnyoApplianceStateEnum, EnyoApplianceTopologyFeatureEnum, EnyoApplianceTypeEnum } from "../../types/enyo-appliance.js";
+import { EnyoDataBusMessageEnum } from "../../types/enyo-data-bus-value.js";
+import { EnyoSourceEnum } from "../../types/enyo-source.enum.js";
+import { EnergyAppModbusConfigurationError, EnergyAppModbusConnectionError } from './interfaces.js';
+import { EnergyAppModbusRegisterMapper } from './EnergyAppModbusRegisterMapper.js';
+import { EnergyAppModbusConnectionHealth } from './EnergyAppModbusConnectionHealth.js';
+import { EnergyAppModbusFaultTolerantReader } from './EnergyAppModbusFaultTolerantReader.js';
+import { EnyoMeterApplianceAvailableFeaturesEnum, } from "../../types/enyo-meter-appliance.js";
+export class EnergyAppModbusMeter {
+    client;
+    config;
+    networkDevice;
+    _registerMapper;
+    _connectionHealth;
+    _modbusInstance;
+    _appliance;
+    constructor(client, config, networkDevice) {
+        this.client = client;
+        this.config = config;
+        this.networkDevice = networkDevice;
+        this.config = config;
+        this.client = client;
+        this.networkDevice = networkDevice;
+        this._registerMapper = new EnergyAppModbusRegisterMapper();
+        this._connectionHealth = new EnergyAppModbusConnectionHealth();
+        // Validate configuration
+        const validation = this._registerMapper.validateRegisterMap(config.registers);
+        if (!validation.valid) {
+            throw new EnergyAppModbusConfigurationError(`Invalid meter configuration: ${validation.errors.join(', ')}`);
+        }
+    }
+    get appliance() {
+        if (!this._appliance) {
+            throw new Error('Meter appliance not initialized. Call connect() first.');
+        }
+        return this._appliance;
+    }
+    async connect() {
+        try {
+            console.log(`Connecting to meter at ${this.networkDevice.hostname}...`);
+            // Create modbus connection
+            this._modbusInstance = await this.client.useModbus().connect({
+                host: this.networkDevice.hostname,
+                unitId: this.config.options?.unitId || 1,
+                port: this.config.options?.port || 502,
+                timeout: this.config.options?.timeout || 5000
+            });
+            // Initialize appliance
+            await this._initializeAppliance();
+            console.log(`Successfully connected to meter ${this.config.name[0]?.name} at ${this.networkDevice.hostname}`);
+        }
+        catch (error) {
+            throw new EnergyAppModbusConnectionError(`Failed to connect to meter at ${this.networkDevice.hostname}: ${error.message}`, error);
+        }
+    }
+    async disconnect() {
+        if (this._modbusInstance) {
+            try {
+                await this._modbusInstance.disconnect();
+                console.log(`Disconnected from meter at ${this.networkDevice.hostname}`);
+            }
+            catch (error) {
+                console.warn(`Error disconnecting from meter: ${error.message}`);
+            }
+            finally {
+                this._modbusInstance = undefined;
+            }
+        }
+    }
+    isConnected() {
+        return this._modbusInstance !== undefined && this._connectionHealth.isHealthy();
+    }
+    async updateData() {
+        if (!this._modbusInstance || !this._appliance) {
+            throw new Error('Meter not connected. Call connect() first.');
+        }
+        const reader = new EnergyAppModbusFaultTolerantReader(this._modbusInstance, this._connectionHealth);
+        const registerData = await this._registerMapper.readMultipleRegisters(reader, this.config.registers);
+        // Extract meter data with fallbacks
+        const gridFeedInPowerW = registerData.gridFeedInPower || 0;
+        const gridConsumptionPowerW = registerData.gridConsumptionPower || 0;
+        const gridFeedInWh = registerData.gridFeedInEnergy || 0;
+        const gridConsumptionWh = registerData.gridConsumptionEnergy || 0;
+        // Calculate net grid power (positive = consumption, negative = feed-in)
+        const gridPowerW = this.config.registers.gridPower !== undefined ? registerData.gridPower : (gridConsumptionPowerW - gridFeedInPowerW);
+        const message = {
+            type: 'message',
+            source: EnyoSourceEnum.Device,
+            id: randomUUID(),
+            timestampIso: new Date().toISOString(),
+            message: EnyoDataBusMessageEnum.MeterValuesUpdateV1,
+            applianceId: this._appliance.id,
+            data: {
+                gridPowerW,
+                gridFeedInWh,
+                gridConsumptionWh
+            },
+            resolution: '10s'
+        };
+        console.log(`Meter Data (${this.config.name[0]?.name}): Grid Power=${gridPowerW}W (Feed-in=${gridFeedInPowerW}W, Consumption=${gridConsumptionPowerW}W), Feed-in Energy=${gridFeedInWh}Wh, Consumption Energy=${gridConsumptionWh}Wh`);
+        return [message];
+    }
+    // Convenience methods for accessing specific register values
+    async getGridPower() {
+        if (!this._modbusInstance) {
+            return null;
+        }
+        const reader = new EnergyAppModbusFaultTolerantReader(this._modbusInstance, this._connectionHealth);
+        // Try direct grid power register first
+        if (this.config.registers.gridPower) {
+            const result = await this._registerMapper.readRegister(reader, this.config.registers.gridPower);
+            if (result.success) {
+                return result.value;
+            }
+        }
+        // Calculate from feed-in and consumption
+        if (this.config.registers.gridFeedInPower && this.config.registers.gridConsumptionPower) {
+            const feedInResult = await this._registerMapper.readRegister(reader, this.config.registers.gridFeedInPower);
+            const consumptionResult = await this._registerMapper.readRegister(reader, this.config.registers.gridConsumptionPower);
+            if (feedInResult.success && consumptionResult.success) {
+                return consumptionResult.value - feedInResult.value;
+            }
+        }
+        return null;
+    }
+    async getGridFeedInEnergy() {
+        if (!this._modbusInstance || !this.config.registers.gridFeedInEnergy) {
+            return null;
+        }
+        const reader = new EnergyAppModbusFaultTolerantReader(this._modbusInstance, this._connectionHealth);
+        const result = await this._registerMapper.readRegister(reader, this.config.registers.gridFeedInEnergy);
+        return result.success ? result.value : null;
+    }
+    async getGridConsumptionEnergy() {
+        if (!this._modbusInstance || !this.config.registers.gridConsumptionEnergy) {
+            return null;
+        }
+        const reader = new EnergyAppModbusFaultTolerantReader(this._modbusInstance, this._connectionHealth);
+        const result = await this._registerMapper.readRegister(reader, this.config.registers.gridConsumptionEnergy);
+        return result.success ? result.value : null;
+    }
+    async _initializeAppliance() {
+        const appliances = await this.client.useAppliances().list();
+        let existingAppliance = appliances.find(a => a.networkDeviceIds.includes(this.networkDevice.id) &&
+            a.type === EnyoApplianceTypeEnum.Meter);
+        if (!existingAppliance) {
+            // Create new appliance
+            existingAppliance = {
+                id: randomUUID(),
+                type: EnyoApplianceTypeEnum.Meter,
+                networkDeviceIds: [this.networkDevice.id],
+                name: this.config.name,
+                metadata: {
+                    state: EnyoApplianceStateEnum.Connected,
+                    connectionType: EnyoApplianceConnectionType.Connector,
+                    ...this.config.options?.topology && { topology: this.config.options.topology }
+                },
+                topology: {
+                    features: [EnyoApplianceTopologyFeatureEnum.IntermediateOfPrimaryMeter]
+                },
+                meter: {
+                    availableFeatures: [EnyoMeterApplianceAvailableFeaturesEnum.LivePowerConsumption, EnyoMeterApplianceAvailableFeaturesEnum.MeterValues]
+                }
+            };
+            await this.client.useAppliances().save(existingAppliance, undefined);
+            console.log(`Created new meter appliance: ${this.config.name[0]?.name}`);
+        }
+        else {
+            // Update existing appliance
+            existingAppliance = {
+                ...existingAppliance,
+                name: this.config.name,
+                metadata: {
+                    ...existingAppliance.metadata,
+                    connectionType: EnyoApplianceConnectionType.Connector,
+                    state: EnyoApplianceStateEnum.Connected,
+                    ...this.config.options?.topology && { topology: this.config.options.topology }
+                },
+                topology: {
+                    features: [EnyoApplianceTopologyFeatureEnum.IntermediateOfPrimaryMeter]
+                },
+                meter: {
+                    availableFeatures: [EnyoMeterApplianceAvailableFeaturesEnum.LivePowerConsumption, EnyoMeterApplianceAvailableFeaturesEnum.MeterValues]
+                }
+            };
+            await this.client.useAppliances().save(existingAppliance, existingAppliance?.id);
+            console.log(`Updated existing meter appliance: ${this.config.name[0]?.name}`);
+        }
+        this._appliance = existingAppliance;
+    }
+    modbusClient() {
+        return this._modbusInstance;
+    }
+}

package/dist/implementations/modbus/EnergyAppModbusRegisterMapper.d.ts

@@ -0,0 +1,13 @@
+import { type IRegisterMapper, type IRegisterReader, type IDataTypeConverter, type EnergyAppModbusRegisterConfig, type EnergyAppRegisterMap, type RegisterReadResult } from './interfaces.js';
+export declare class EnergyAppModbusRegisterMapper implements IRegisterMapper {
+    private readonly dataTypeConverter;
+    constructor(dataTypeConverter?: IDataTypeConverter);
+    readRegister<T>(reader: IRegisterReader, config: EnergyAppModbusRegisterConfig): Promise<RegisterReadResult<T>>;
+    readMultipleRegisters(reader: IRegisterReader, registerMap: EnergyAppRegisterMap): Promise<{
+        [key: string]: any;
+    }>;
+    validateRegisterMap(registerMap: EnergyAppRegisterMap): {
+        valid: boolean;
+        errors: string[];
+    };
+}

package/dist/implementations/modbus/EnergyAppModbusRegisterMapper.js

@@ -0,0 +1,94 @@
+import { EnergyAppModbusReadError } from './interfaces.js';
+import { EnergyAppModbusDataTypeConverter } from './EnergyAppModbusDataTypeConverter.js';
+export class EnergyAppModbusRegisterMapper {
+    dataTypeConverter;
+    constructor(dataTypeConverter) {
+        this.dataTypeConverter = dataTypeConverter || new EnergyAppModbusDataTypeConverter();
+    }
+    async readRegister(reader, config) {
+        try {
+            // Calculate quantity if not provided
+            const quantity = config.quantity || this.dataTypeConverter.getRegisterQuantity(config.dataType);
+            const result = await reader.readHoldingRegisters(config.address, quantity);
+            if (!result.success || !result.value) {
+                return {
+                    success: false,
+                    error: new EnergyAppModbusReadError(`Failed to read register ${config.address}: ${result.error?.message || 'Unknown error'}`, config.address)
+                };
+            }
+            const convertedValue = this.dataTypeConverter.convertFromBuffer(result.value, config.dataType, config.scale, config.quantity);
+            // Validate the converted value
+            if (!this.dataTypeConverter.isValidValue(convertedValue, config.dataType)) {
+                return {
+                    success: false,
+                    error: new EnergyAppModbusReadError(`Invalid value 0x${convertedValue.toString(16)} for register ${config.address}`, config.address)
+                };
+            }
+            return {
+                success: true,
+                value: convertedValue
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: new EnergyAppModbusReadError(`Error reading register ${config.address}: ${error.message}`, config.address)
+            };
+        }
+    }
+    async readMultipleRegisters(reader, registerMap) {
+        const results = {};
+        const failures = [];
+        // Read all registers
+        for (const [name, config] of Object.entries(registerMap)) {
+            if (!config) {
+                continue;
+            }
+            const result = await this.readRegister(reader, config);
+            if (result.success) {
+                results[name] = result.value;
+            }
+            else {
+                // Check if this register was required
+                if (config.required) {
+                    failures.push(`${name} (${config.address})`);
+                }
+                console.warn(`Failed to read register ${name} (${config.address}): ${result.error?.message}`);
+            }
+        }
+        // If any required registers failed, log warning
+        if (failures.length > 0) {
+            console.warn(`Failed to read required registers: ${failures.join(', ')}`);
+        }
+        return results;
+    }
+    validateRegisterMap(registerMap) {
+        const errors = [];
+        for (const [name, config] of Object.entries(registerMap)) {
+            if (!config) {
+                continue;
+            }
+            // Validate address
+            if (!Number.isInteger(config.address) || config.address < 1) {
+                errors.push(`Invalid address for register '${name}': ${config.address}`);
+            }
+            // Validate data type
+            const validDataTypes = ['uint16', 'int16', 'uint32', 'int32', 'float32', 'string'];
+            if (!validDataTypes.includes(config.dataType)) {
+                errors.push(`Invalid data type for register '${name}': ${config.dataType}`);
+            }
+            // Validate scale
+            if (config.scale !== undefined && (!Number.isInteger(config.scale) || config.scale < 0)) {
+                errors.push(`Invalid scale for register '${name}': ${config.scale}`);
+            }
+            // Validate quantity
+            if (config.quantity !== undefined && (!Number.isInteger(config.quantity) || config.quantity < 1)) {
+                errors.push(`Invalid quantity for register '${name}': ${config.quantity}`);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+}

package/dist/implementations/modbus/interfaces.d.ts

@@ -0,0 +1,202 @@
+import type { EnergyApp } from "../../index.js";
+import type { EnyoNetworkDevice } from "../../types/enyo-network-device.js";
+import type { EnyoAppliance, EnyoApplianceName, EnyoApplianceTopology } from "../../types/enyo-appliance.js";
+import { EnyoBatteryStateEnum, EnyoDataBusMessage, EnyoInverterStateEnum } from "../../types/enyo-data-bus-value.js";
+import { EnergyAppModbusInstance } from "../../packages/energy-app-modbus.js";
+/**
+ * Data Types for Modbus Register Configuration
+ *
+ * @description Supported data types for reading Modbus registers
+ * - Numeric types: uint16, int16, uint32, int32, float32
+ * - String type: string (requires length property in register config)
+ */
+export type EnergyAppModbusDataType = 'uint16' | 'int16' | 'uint32' | 'int32' | 'float32' | 'string';
+export interface EnergyAppBatteryStateValueMapping {
+    value: number;
+    mappedState: EnyoBatteryStateEnum;
+}
+export interface EnergyAppInverterStateValueMapping {
+    value: number;
+    mappedState: EnyoInverterStateEnum;
+}
+/**
+ * Register Configuration Interface
+ *
+ * @description Configuration for reading a Modbus register
+ */
+export interface EnergyAppModbusRegisterConfig {
+    /** Modbus register address */
+    address: number;
+    /** Data type of the register value */
+    dataType: EnergyAppModbusDataType;
+    /** For FIX2, FIX3 scaling (divide by 10^scale) - only applies to numeric types */
+    scale?: number;
+    /** Number of registers to read (auto-calculated from dataType if not provided) */
+    quantity?: number;
+    /** Whether this register is required for device operation */
+    required?: boolean;
+    /** For mapping numeric values to enum states (only applies to numeric types) */
+    valueMapping?: EnergyAppBatteryStateValueMapping[] | EnergyAppInverterStateValueMapping[];
+}
+export interface EnergyAppRegisterMap {
+    [key: string]: EnergyAppModbusRegisterConfig | undefined;
+}
+export interface EnergyAppModbusConnectionOptions {
+    unitId?: number;
+    port?: number;
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+}
+export interface EnergyAppModbusDeviceConfig {
+    name: EnyoApplianceName[];
+    registers: EnergyAppRegisterMap;
+    options?: EnergyAppModbusConnectionOptions & {
+        topology?: EnyoApplianceTopology;
+    };
+}
+export interface EnergyAppModbusInverterConfig extends EnergyAppModbusDeviceConfig {
+    registers: {
+        serialNumber?: EnergyAppModbusRegisterConfig;
+        power?: EnergyAppModbusRegisterConfig;
+        voltageL1?: EnergyAppModbusRegisterConfig;
+        voltageL2?: EnergyAppModbusRegisterConfig;
+        voltageL3?: EnergyAppModbusRegisterConfig;
+        maxPvProductionW?: EnergyAppModbusRegisterConfig;
+        state?: EnergyAppModbusRegisterConfig;
+        activePowerLimitationW?: EnergyAppModbusRegisterConfig;
+        string1Power?: EnergyAppModbusRegisterConfig;
+        string1Voltage?: EnergyAppModbusRegisterConfig;
+        string2Power?: EnergyAppModbusRegisterConfig;
+        string2Voltage?: EnergyAppModbusRegisterConfig;
+        string3Power?: EnergyAppModbusRegisterConfig;
+        string3Voltage?: EnergyAppModbusRegisterConfig;
+        string4Power?: EnergyAppModbusRegisterConfig;
+        string4Voltage?: EnergyAppModbusRegisterConfig;
+        [key: string]: EnergyAppModbusRegisterConfig | undefined;
+    };
+}
+export interface EnergyAppModbusBatteryConfig extends EnergyAppModbusDeviceConfig {
+    inverter?: IEnergyAppModbusInverter;
+    registers: {
+        current?: EnergyAppModbusRegisterConfig;
+        voltage?: EnergyAppModbusRegisterConfig;
+        soc?: EnergyAppModbusRegisterConfig;
+        power?: EnergyAppModbusRegisterConfig;
+        temperature?: EnergyAppModbusRegisterConfig;
+        state?: EnergyAppModbusRegisterConfig;
+        maxCapacityWh?: EnergyAppModbusRegisterConfig;
+        maxDischargePowerW?: EnergyAppModbusRegisterConfig;
+        maxChargingPowerW?: EnergyAppModbusRegisterConfig;
+        drainPercentage?: EnergyAppModbusRegisterConfig;
+        loadPercentage?: EnergyAppModbusRegisterConfig;
+        [key: string]: EnergyAppModbusRegisterConfig | undefined;
+    };
+}
+export interface EnergyAppModbusMeterConfig extends EnergyAppModbusDeviceConfig {
+    registers: {
+        gridPower?: EnergyAppModbusRegisterConfig;
+        gridFeedInPower?: EnergyAppModbusRegisterConfig;
+        gridConsumptionPower?: EnergyAppModbusRegisterConfig;
+        gridFeedInEnergy?: EnergyAppModbusRegisterConfig;
+        gridConsumptionEnergy?: EnergyAppModbusRegisterConfig;
+        [key: string]: EnergyAppModbusRegisterConfig | undefined;
+    };
+}
+export interface RegisterReadResult<T = any> {
+    success: boolean;
+    value?: T;
+    error?: Error;
+}
+export interface IRegisterReader {
+    readHoldingRegisters(startAddress: number, quantity: number): Promise<RegisterReadResult<Buffer>>;
+    readInputRegisters?(startAddress: number, quantity: number): Promise<RegisterReadResult<Buffer>>;
+    isHealthy(): boolean;
+}
+export interface IRegisterMapper {
+    readRegister<T>(reader: IRegisterReader, config: EnergyAppModbusRegisterConfig): Promise<RegisterReadResult<T>>;
+    readMultipleRegisters(reader: IRegisterReader, registerMap: EnergyAppRegisterMap): Promise<{
+        [key: string]: any;
+    }>;
+    validateRegisterMap(registerMap: EnergyAppRegisterMap): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+/**
+ * Data Type Converter Interface
+ *
+ * @description Interface for converting raw Modbus buffer data into appropriate JavaScript types
+ */
+export interface IDataTypeConverter {
+    /**
+     * Converts raw buffer data from Modbus registers into appropriate JavaScript types
+     *
+     * @param buffer - Raw buffer data from Modbus registers
+     * @param dataType - The expected data type for conversion
+     * @param scale - Optional scaling factor for numeric types (divide by 10^scale)
+     * @param quantity - Required for string types, specifies the string length in characters
+     */
+    convertFromBuffer(buffer: Buffer, dataType: EnergyAppModbusDataType, scale?: number, quantity?: number): any;
+    /**
+     * Validates if a value is valid for the given data type
+     *
+     * @param value - The value to validate
+     * @param dataType - The expected data type
+     */
+    isValidValue(value: any, dataType: EnergyAppModbusDataType): boolean;
+    /**
+     * Calculates the number of Modbus registers required for a given data type
+     *
+     * @param dataType - The data type to calculate register quantity for
+     */
+    getRegisterQuantity(dataType: EnergyAppModbusDataType): number;
+}
+export interface IConnectionHealth {
+    recordSuccess(): void;
+    recordFailure(error: Error): void;
+    isHealthy(): boolean;
+    getConsecutiveFailures(): number;
+    getLastError(): Error | undefined;
+}
+export interface EnergyAppModbusDevice {
+    readonly client: EnergyApp;
+    readonly config: EnergyAppModbusDeviceConfig;
+    readonly appliance: EnyoAppliance;
+    readonly networkDevice: EnyoNetworkDevice;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    updateData(): Promise<EnyoDataBusMessage[]>;
+    modbusClient(): EnergyAppModbusInstance | undefined;
+}
+export interface IEnergyAppModbusInverter extends EnergyAppModbusDevice {
+    readonly config: EnergyAppModbusInverterConfig;
+    getSerialNumber(): Promise<string | null>;
+    getCurrentPower(): Promise<number | null>;
+    getTotalEnergy(): Promise<number | null>;
+}
+export interface IEnergyAppModbusBattery extends EnergyAppModbusDevice {
+    readonly config: EnergyAppModbusBatteryConfig;
+    readonly inverter?: IEnergyAppModbusInverter;
+    getSoc(): Promise<number | null>;
+    getCurrent(): Promise<number | null>;
+    getPower(): Promise<number | null>;
+}
+export interface IEnergyAppModbusMeter extends EnergyAppModbusDevice {
+    readonly config: EnergyAppModbusMeterConfig;
+    getGridPower(): Promise<number | null>;
+    getGridFeedInEnergy(): Promise<number | null>;
+    getGridConsumptionEnergy(): Promise<number | null>;
+}
+export declare class EnergyAppModbusConfigurationError extends Error {
+    constructor(message: string);
+}
+export declare class EnergyAppModbusConnectionError extends Error {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+export declare class EnergyAppModbusReadError extends Error {
+    readonly register?: number | undefined;
+    constructor(message: string, register?: number | undefined);
+}

package/dist/implementations/modbus/interfaces.js

@@ -0,0 +1,23 @@
+// Error types
+export class EnergyAppModbusConfigurationError extends Error {
+    constructor(message) {
+        super(`Modbus Configuration Error: ${message}`);
+        this.name = 'ModbusConfigurationError';
+    }
+}
+export class EnergyAppModbusConnectionError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(`Modbus Connection Error: ${message}`);
+        this.cause = cause;
+        this.name = 'ModbusConnectionError';
+    }
+}
+export class EnergyAppModbusReadError extends Error {
+    register;
+    constructor(message, register) {
+        super(`Modbus Read Error: ${message}`);
+        this.register = register;
+        this.name = 'ModbusReadError';
+    }
+}

package/dist/implementations/ocpp/ocpp-common.d.ts

@@ -0,0 +1,75 @@
+export type OCPPVersion = '1.6' | '2.0.1';
+export type MessageType = 2 | 3 | 4;
+export declare const MESSAGE_TYPE: {
+    readonly CALL: 2;
+    readonly CALLRESULT: 3;
+    readonly CALLERROR: 4;
+};
+export interface OCPPMessage {
+    messageType: MessageType;
+    messageId: string;
+    action?: string;
+    payload?: any;
+    errorCode?: string;
+    errorDescription?: string;
+    errorDetails?: any;
+}
+export interface CallMessage extends OCPPMessage {
+    messageType: typeof MESSAGE_TYPE.CALL;
+    action: string;
+    payload: any;
+}
+export interface CallResultMessage extends OCPPMessage {
+    messageType: typeof MESSAGE_TYPE.CALLRESULT;
+    payload: any;
+}
+export interface CallErrorMessage extends OCPPMessage {
+    messageType: typeof MESSAGE_TYPE.CALLERROR;
+    errorCode: string;
+    errorDescription: string;
+    errorDetails?: any;
+}
+export type OCPPMessageUnion = CallMessage | CallResultMessage | CallErrorMessage;
+export declare enum ErrorCode {
+    NotImplemented = "NotImplemented",
+    NotSupported = "NotSupported",
+    InternalError = "InternalError",
+    ProtocolError = "ProtocolError",
+    SecurityError = "SecurityError",
+    FormationViolation = "FormationViolation",
+    PropertyConstraintViolation = "PropertyConstraintViolation",
+    OccurenceConstraintViolation = "OccurenceConstraintViolation",
+    TypeConstraintViolation = "TypeConstraintViolation",
+    GenericError = "GenericError"
+}
+export declare enum GenericChargePointStatus {
+    Available = "Available",
+    Occupied = "Occupied",
+    Suspended = "Suspended",
+    Finishing = "Finishing",
+    Reserved = "Reserved",
+    Unavailable = "Unavailable",
+    Faulted = "Faulted"
+}
+import { ChargePointStatus, OCPP16MeterValueSampledValue } from './ocpp16.js';
+import { ConnectorStatusEnumType, OCPP201TransactionEventRequest } from './ocpp201.js';
+export type OCPP201MeterValueSampledValue = NonNullable<NonNullable<OCPP201TransactionEventRequest['meterValue']>[number]['sampledValue'][number]>;
+export declare function mapOCCP16StatusToGeneric(status: ChargePointStatus): GenericChargePointStatus;
+export declare function mapOCCP201StatusToGeneric(connectorStatus: ConnectorStatusEnumType, chargingState?: 'Charging' | 'EVConnected' | 'SuspendedEV' | 'SuspendedEVSE' | 'Idle'): GenericChargePointStatus;
+export declare function mapGenericToOCCP16Status(status: GenericChargePointStatus): ChargePointStatus;
+export declare function mapGenericToOCCP201Status(status: GenericChargePointStatus): ConnectorStatusEnumType;
+export type GenericOcppMeterValueContext = 'Transaction.Begin' | 'Transaction.End' | 'Sample.Clock' | 'Sample.Periodic' | 'Trigger' | 'Interruption.Begin' | 'Interruption.End';
+export interface GenericOcppMeterValues {
+    context?: GenericOcppMeterValueContext;
+    outletVoltagePhase1: number;
+    outletVoltagePhase2: number;
+    outletVoltagePhase3: number;
+    outletCurrentPhase1: number;
+    outletCurrentPhase2: number;
+    outletCurrentPhase3: number;
+    powerImportByEvInWatt: number;
+    evStateOfChargeInPercent: number;
+    currentMeterValueInWattHours: number;
+}
+export declare function mapOCPP16MeterValueToGeneric(sampledValues: OCPP16MeterValueSampledValue[]): GenericOcppMeterValues;
+export declare function mapOCPP201MeterValueToGeneric(sampledValues: OCPP201MeterValueSampledValue[]): GenericOcppMeterValues;