@enyo-energy/energy-app-sdk 0.0.34

package/dist/cjs/implementations/ocpp/ocpp-common.cjs

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericChargePointStatus = exports.ErrorCode = exports.MESSAGE_TYPE = void 0;
+exports.mapOCCP16StatusToGeneric = mapOCCP16StatusToGeneric;
+exports.mapOCCP201StatusToGeneric = mapOCCP201StatusToGeneric;
+exports.mapGenericToOCCP16Status = mapGenericToOCCP16Status;
+exports.mapGenericToOCCP201Status = mapGenericToOCCP201Status;
+exports.mapOCPP16MeterValueToGeneric = mapOCPP16MeterValueToGeneric;
+exports.mapOCPP201MeterValueToGeneric = mapOCPP201MeterValueToGeneric;
+exports.MESSAGE_TYPE = {
+    CALL: 2,
+    CALLRESULT: 3,
+    CALLERROR: 4,
+};
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["NotImplemented"] = "NotImplemented";
+    ErrorCode["NotSupported"] = "NotSupported";
+    ErrorCode["InternalError"] = "InternalError";
+    ErrorCode["ProtocolError"] = "ProtocolError";
+    ErrorCode["SecurityError"] = "SecurityError";
+    ErrorCode["FormationViolation"] = "FormationViolation";
+    ErrorCode["PropertyConstraintViolation"] = "PropertyConstraintViolation";
+    ErrorCode["OccurenceConstraintViolation"] = "OccurenceConstraintViolation";
+    ErrorCode["TypeConstraintViolation"] = "TypeConstraintViolation";
+    ErrorCode["GenericError"] = "GenericError";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+var GenericChargePointStatus;
+(function (GenericChargePointStatus) {
+    GenericChargePointStatus["Available"] = "Available";
+    GenericChargePointStatus["Occupied"] = "Occupied";
+    GenericChargePointStatus["Suspended"] = "Suspended";
+    GenericChargePointStatus["Finishing"] = "Finishing";
+    GenericChargePointStatus["Reserved"] = "Reserved";
+    GenericChargePointStatus["Unavailable"] = "Unavailable";
+    GenericChargePointStatus["Faulted"] = "Faulted";
+})(GenericChargePointStatus || (exports.GenericChargePointStatus = GenericChargePointStatus = {}));
+const ocpp16_js_1 = require("./ocpp16.cjs");
+const ocpp201_js_1 = require("./ocpp201.cjs");
+function mapOCCP16StatusToGeneric(status) {
+    switch (status) {
+        case ocpp16_js_1.ChargePointStatus.Available:
+            return GenericChargePointStatus.Available;
+        case ocpp16_js_1.ChargePointStatus.Preparing:
+        case ocpp16_js_1.ChargePointStatus.Charging:
+            return GenericChargePointStatus.Occupied;
+        case ocpp16_js_1.ChargePointStatus.SuspendedEVSE:
+        case ocpp16_js_1.ChargePointStatus.SuspendedEV:
+            return GenericChargePointStatus.Suspended;
+        case ocpp16_js_1.ChargePointStatus.Finishing:
+            return GenericChargePointStatus.Finishing;
+        case ocpp16_js_1.ChargePointStatus.Reserved:
+            return GenericChargePointStatus.Reserved;
+        case ocpp16_js_1.ChargePointStatus.Unavailable:
+            return GenericChargePointStatus.Unavailable;
+        case ocpp16_js_1.ChargePointStatus.Faulted:
+            return GenericChargePointStatus.Faulted;
+        default:
+            return GenericChargePointStatus.Unavailable;
+    }
+}
+function mapOCCP201StatusToGeneric(connectorStatus, chargingState) {
+    if (connectorStatus === ocpp201_js_1.ConnectorStatusEnumType.Available) {
+        return GenericChargePointStatus.Available;
+    }
+    if (connectorStatus === ocpp201_js_1.ConnectorStatusEnumType.Reserved) {
+        return GenericChargePointStatus.Reserved;
+    }
+    if (connectorStatus === ocpp201_js_1.ConnectorStatusEnumType.Unavailable) {
+        return GenericChargePointStatus.Unavailable;
+    }
+    if (connectorStatus === ocpp201_js_1.ConnectorStatusEnumType.Faulted) {
+        return GenericChargePointStatus.Faulted;
+    }
+    if (connectorStatus === ocpp201_js_1.ConnectorStatusEnumType.Occupied) {
+        if (chargingState === 'SuspendedEV' || chargingState === 'SuspendedEVSE') {
+            return GenericChargePointStatus.Suspended;
+        }
+        if (chargingState === 'Charging' || chargingState === 'EVConnected') {
+            return GenericChargePointStatus.Occupied;
+        }
+        if (chargingState === 'Idle') {
+            return GenericChargePointStatus.Finishing;
+        }
+        return GenericChargePointStatus.Occupied;
+    }
+    return GenericChargePointStatus.Unavailable;
+}
+function mapGenericToOCCP16Status(status) {
+    switch (status) {
+        case GenericChargePointStatus.Available:
+            return ocpp16_js_1.ChargePointStatus.Available;
+        case GenericChargePointStatus.Occupied:
+            return ocpp16_js_1.ChargePointStatus.Charging;
+        case GenericChargePointStatus.Suspended:
+            return ocpp16_js_1.ChargePointStatus.SuspendedEVSE;
+        case GenericChargePointStatus.Finishing:
+            return ocpp16_js_1.ChargePointStatus.Finishing;
+        case GenericChargePointStatus.Reserved:
+            return ocpp16_js_1.ChargePointStatus.Reserved;
+        case GenericChargePointStatus.Unavailable:
+            return ocpp16_js_1.ChargePointStatus.Unavailable;
+        case GenericChargePointStatus.Faulted:
+            return ocpp16_js_1.ChargePointStatus.Faulted;
+        default:
+            return ocpp16_js_1.ChargePointStatus.Unavailable;
+    }
+}
+function mapGenericToOCCP201Status(status) {
+    switch (status) {
+        case GenericChargePointStatus.Available:
+            return ocpp201_js_1.ConnectorStatusEnumType.Available;
+        case GenericChargePointStatus.Occupied:
+        case GenericChargePointStatus.Suspended:
+        case GenericChargePointStatus.Finishing:
+            return ocpp201_js_1.ConnectorStatusEnumType.Occupied;
+        case GenericChargePointStatus.Reserved:
+            return ocpp201_js_1.ConnectorStatusEnumType.Reserved;
+        case GenericChargePointStatus.Unavailable:
+            return ocpp201_js_1.ConnectorStatusEnumType.Unavailable;
+        case GenericChargePointStatus.Faulted:
+            return ocpp201_js_1.ConnectorStatusEnumType.Faulted;
+        default:
+            return ocpp201_js_1.ConnectorStatusEnumType.Unavailable;
+    }
+}
+function mapOCPP16MeterValueToGeneric(sampledValues) {
+    const currentMeterValueInWattHours = getOCPP16MeterValueByMeasurand(sampledValues, 'Energy.Active.Import.Register');
+    const powerActiveImport = getOCPP16MeterValueByMeasurand(sampledValues, 'Power.Active.Import');
+    const evSoC = getOCPP16MeterValueByMeasurand(sampledValues, 'SoC');
+    const outletVoltage = getOCPP16OutletVoltage(sampledValues);
+    const outletCurrent = getOCPP16OutletCurrent(sampledValues);
+    return {
+        context: mapOCPP16MeterValueContext(sampledValues),
+        currentMeterValueInWattHours: convertToWattHours(currentMeterValueInWattHours),
+        powerImportByEvInWatt: convertToWatt(powerActiveImport),
+        evStateOfChargeInPercent: convertToPercent(evSoC),
+        outletVoltagePhase1: convertToVoltage(outletVoltage.phase1),
+        outletVoltagePhase2: convertToVoltage(outletVoltage.phase2),
+        outletVoltagePhase3: convertToVoltage(outletVoltage.phase3),
+        outletCurrentPhase1: convertToAmpere(outletCurrent.phase1),
+        outletCurrentPhase2: convertToAmpere(outletCurrent.phase2),
+        outletCurrentPhase3: convertToAmpere(outletCurrent.phase3),
+    };
+}
+function mapOCPP16MeterValueContext(sampledValues) {
+    const valuesWithContext = sampledValues.filter(s => s.context !== undefined);
+    if (valuesWithContext.length > 0) {
+        switch (valuesWithContext[0].context) {
+            case 'Transaction.Begin':
+                return 'Transaction.Begin';
+            case "Transaction.End":
+                return 'Transaction.End';
+            case "Sample.Clock":
+                return 'Sample.Clock';
+            case "Interruption.Begin":
+                return 'Interruption.Begin';
+            case "Interruption.End":
+                return 'Interruption.End';
+            case "Sample.Periodic":
+                return 'Sample.Periodic';
+            case "Trigger":
+                return 'Trigger';
+            default:
+                return undefined;
+        }
+    }
+    return undefined;
+}
+function getOCPP16MeterValueByMeasurand(sampledValues, measurand, phase) {
+    try {
+        const meterValue = sampledValues.find((sampledValue) => sampledValue.measurand === measurand &&
+            (!phase || sampledValue.phase === phase));
+        if (!meterValue) {
+            return undefined;
+        }
+        return {
+            unit: meterValue.unit,
+            value: Number.parseFloat(meterValue.value),
+            context: meterValue.context,
+        };
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+function getOCPP16OutletCurrent(sampledValues) {
+    const phase1 = getOCPP16MeterValueByMeasurand(sampledValues, 'Current.Import', 'L1');
+    const phase2 = getOCPP16MeterValueByMeasurand(sampledValues, 'Current.Import', 'L2');
+    const phase3 = getOCPP16MeterValueByMeasurand(sampledValues, 'Current.Import', 'L3');
+    return {
+        phase1,
+        phase2,
+        phase3,
+    };
+}
+function getOCPP16OutletVoltage(sampledValues) {
+    const phase1 = getOCPP16MeterValueByMeasurand(sampledValues, 'Voltage', 'L1');
+    const phase2 = getOCPP16MeterValueByMeasurand(sampledValues, 'Voltage', 'L2');
+    const phase3 = getOCPP16MeterValueByMeasurand(sampledValues, 'Voltage', 'L3');
+    return {
+        phase1,
+        phase2,
+        phase3,
+    };
+}
+function convertToWattHours(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'Wh') {
+        return instance.value;
+    }
+    if (instance.unit === 'kWh') {
+        return instance.value * 1000;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into Wh`);
+}
+function convertToWatt(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'W') {
+        return instance.value;
+    }
+    if (instance.unit === 'kW') {
+        return instance.value * 1000;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into W`);
+}
+function convertToPercent(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'Percent') {
+        return instance.value;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into Percent`);
+}
+function convertToVoltage(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'V') {
+        return instance.value;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into V`);
+}
+function convertToAmpere(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'A') {
+        return instance.value;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into A`);
+}
+// OCPP 2.0.1 meter value mapping functions
+function mapOCPP201MeterValueToGeneric(sampledValues) {
+    const currentMeterValueInWattHours = getOCPP201MeterValueByMeasurand(sampledValues, 'Energy.Active.Import');
+    const powerActiveImport = getOCPP201MeterValueByMeasurand(sampledValues, 'Power.Active.Import');
+    const evSoC = getOCPP201MeterValueByMeasurand(sampledValues, 'SoC');
+    const outletVoltage = getOCPP201OutletVoltage(sampledValues);
+    const outletCurrent = getOCPP201OutletCurrent(sampledValues);
+    return {
+        context: mapOCPP201MeterValueContext(sampledValues),
+        currentMeterValueInWattHours: convertToWattHours(currentMeterValueInWattHours),
+        powerImportByEvInWatt: convertToWatt(powerActiveImport),
+        evStateOfChargeInPercent: convertToPercent(evSoC),
+        outletVoltagePhase1: convertToVoltage(outletVoltage.phase1),
+        outletVoltagePhase2: convertToVoltage(outletVoltage.phase2),
+        outletVoltagePhase3: convertToVoltage(outletVoltage.phase3),
+        outletCurrentPhase1: convertToAmpere(outletCurrent.phase1),
+        outletCurrentPhase2: convertToAmpere(outletCurrent.phase2),
+        outletCurrentPhase3: convertToAmpere(outletCurrent.phase3),
+    };
+}
+function mapOCPP201MeterValueContext(sampledValues) {
+    const valuesWithContext = sampledValues.filter(s => s.context !== undefined);
+    if (valuesWithContext.length > 0) {
+        switch (valuesWithContext[0].context) {
+            case 'Transaction.Begin':
+                return 'Transaction.Begin';
+            case "Transaction.End":
+                return 'Transaction.End';
+            case "Sample.Clock":
+                return 'Sample.Clock';
+            case "Interruption.Begin":
+                return 'Interruption.Begin';
+            case "Interruption.End":
+                return 'Interruption.End';
+            case "Sample.Periodic":
+                return 'Sample.Periodic';
+            case "Trigger":
+                return 'Trigger';
+            default:
+                return undefined;
+        }
+    }
+    return undefined;
+}
+function getOCPP201MeterValueByMeasurand(sampledValues, measurand, phase) {
+    try {
+        const meterValue = sampledValues.find((sampledValue) => sampledValue.measurand === measurand &&
+            (!phase || sampledValue.phase === phase));
+        if (!meterValue) {
+            return undefined;
+        }
+        return {
+            unit: meterValue.unitOfMeasure?.unit,
+            value: meterValue.value,
+        };
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+function getOCPP201OutletCurrent(sampledValues) {
+    const phase1 = getOCPP201MeterValueByMeasurand(sampledValues, 'Current.Import', 'L1');
+    const phase2 = getOCPP201MeterValueByMeasurand(sampledValues, 'Current.Import', 'L2');
+    const phase3 = getOCPP201MeterValueByMeasurand(sampledValues, 'Current.Import', 'L3');
+    return {
+        phase1,
+        phase2,
+        phase3,
+    };
+}
+function getOCPP201OutletVoltage(sampledValues) {
+    const phase1 = getOCPP201MeterValueByMeasurand(sampledValues, 'Voltage', 'L1');
+    const phase2 = getOCPP201MeterValueByMeasurand(sampledValues, 'Voltage', 'L2');
+    const phase3 = getOCPP201MeterValueByMeasurand(sampledValues, 'Voltage', 'L3');
+    return {
+        phase1,
+        phase2,
+        phase3,
+    };
+}

package/dist/cjs/implementations/ocpp/ocpp-common.d.cts

@@ -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.cjs';
+import { ConnectorStatusEnumType, OCPP201TransactionEventRequest } from './ocpp201.cjs';
+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;

package/dist/cjs/implementations/ocpp/ocpp16.cjs

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargePointStatus = exports.RegistrationStatus = exports.OCPP16Action = void 0;
+var OCPP16Action;
+(function (OCPP16Action) {
+    OCPP16Action["Authorize"] = "Authorize";
+    OCPP16Action["BootNotification"] = "BootNotification";
+    OCPP16Action["CancelReservation"] = "CancelReservation";
+    OCPP16Action["ChangeAvailability"] = "ChangeAvailability";
+    OCPP16Action["ChangeConfiguration"] = "ChangeConfiguration";
+    OCPP16Action["ClearCache"] = "ClearCache";
+    OCPP16Action["ClearChargingProfile"] = "ClearChargingProfile";
+    OCPP16Action["DataTransfer"] = "DataTransfer";
+    OCPP16Action["DiagnosticsStatusNotification"] = "DiagnosticsStatusNotification";
+    OCPP16Action["FirmwareStatusNotification"] = "FirmwareStatusNotification";
+    OCPP16Action["GetConfiguration"] = "GetConfiguration";
+    OCPP16Action["GetDiagnostics"] = "GetDiagnostics";
+    OCPP16Action["GetLocalListVersion"] = "GetLocalListVersion";
+    OCPP16Action["Heartbeat"] = "Heartbeat";
+    OCPP16Action["MeterValues"] = "MeterValues";
+    OCPP16Action["RemoteStartTransaction"] = "RemoteStartTransaction";
+    OCPP16Action["RemoteStopTransaction"] = "RemoteStopTransaction";
+    OCPP16Action["ReserveNow"] = "ReserveNow";
+    OCPP16Action["Reset"] = "Reset";
+    OCPP16Action["SendLocalList"] = "SendLocalList";
+    OCPP16Action["SetChargingProfile"] = "SetChargingProfile";
+    OCPP16Action["StartTransaction"] = "StartTransaction";
+    OCPP16Action["StatusNotification"] = "StatusNotification";
+    OCPP16Action["StopTransaction"] = "StopTransaction";
+    OCPP16Action["TriggerMessage"] = "TriggerMessage";
+    OCPP16Action["UnlockConnector"] = "UnlockConnector";
+    OCPP16Action["UpdateFirmware"] = "UpdateFirmware";
+})(OCPP16Action || (exports.OCPP16Action = OCPP16Action = {}));
+var RegistrationStatus;
+(function (RegistrationStatus) {
+    RegistrationStatus["Accepted"] = "Accepted";
+    RegistrationStatus["Pending"] = "Pending";
+    RegistrationStatus["Rejected"] = "Rejected";
+})(RegistrationStatus || (exports.RegistrationStatus = RegistrationStatus = {}));
+var ChargePointStatus;
+(function (ChargePointStatus) {
+    ChargePointStatus["Available"] = "Available";
+    ChargePointStatus["Preparing"] = "Preparing";
+    ChargePointStatus["Charging"] = "Charging";
+    ChargePointStatus["SuspendedEVSE"] = "SuspendedEVSE";
+    ChargePointStatus["SuspendedEV"] = "SuspendedEV";
+    ChargePointStatus["Finishing"] = "Finishing";
+    ChargePointStatus["Reserved"] = "Reserved";
+    ChargePointStatus["Unavailable"] = "Unavailable";
+    ChargePointStatus["Faulted"] = "Faulted";
+})(ChargePointStatus || (exports.ChargePointStatus = ChargePointStatus = {}));

package/dist/cjs/implementations/ocpp/ocpp16.d.cts

@@ -0,0 +1,137 @@
+export declare enum OCPP16Action {
+    Authorize = "Authorize",
+    BootNotification = "BootNotification",
+    CancelReservation = "CancelReservation",
+    ChangeAvailability = "ChangeAvailability",
+    ChangeConfiguration = "ChangeConfiguration",
+    ClearCache = "ClearCache",
+    ClearChargingProfile = "ClearChargingProfile",
+    DataTransfer = "DataTransfer",
+    DiagnosticsStatusNotification = "DiagnosticsStatusNotification",
+    FirmwareStatusNotification = "FirmwareStatusNotification",
+    GetConfiguration = "GetConfiguration",
+    GetDiagnostics = "GetDiagnostics",
+    GetLocalListVersion = "GetLocalListVersion",
+    Heartbeat = "Heartbeat",
+    MeterValues = "MeterValues",
+    RemoteStartTransaction = "RemoteStartTransaction",
+    RemoteStopTransaction = "RemoteStopTransaction",
+    ReserveNow = "ReserveNow",
+    Reset = "Reset",
+    SendLocalList = "SendLocalList",
+    SetChargingProfile = "SetChargingProfile",
+    StartTransaction = "StartTransaction",
+    StatusNotification = "StatusNotification",
+    StopTransaction = "StopTransaction",
+    TriggerMessage = "TriggerMessage",
+    UnlockConnector = "UnlockConnector",
+    UpdateFirmware = "UpdateFirmware"
+}
+export declare enum RegistrationStatus {
+    Accepted = "Accepted",
+    Pending = "Pending",
+    Rejected = "Rejected"
+}
+export declare enum ChargePointStatus {
+    Available = "Available",
+    Preparing = "Preparing",
+    Charging = "Charging",
+    SuspendedEVSE = "SuspendedEVSE",
+    SuspendedEV = "SuspendedEV",
+    Finishing = "Finishing",
+    Reserved = "Reserved",
+    Unavailable = "Unavailable",
+    Faulted = "Faulted"
+}
+export interface OCPP16BootNotificationRequest {
+    chargePointVendor: string;
+    chargePointModel: string;
+    chargePointSerialNumber?: string;
+    chargeBoxSerialNumber?: string;
+    firmwareVersion?: string;
+    iccid?: string;
+    imsi?: string;
+    meterSerialNumber?: string;
+    meterType?: string;
+}
+export interface OCPP16BootNotificationResponse {
+    status: RegistrationStatus;
+    currentTime: string;
+    interval: number;
+}
+export interface OCPP16HeartbeatRequest {
+}
+export interface OCPP16HeartbeatResponse {
+    currentTime: string;
+}
+export interface OCPP16StatusNotificationRequest {
+    connectorId: number;
+    status: ChargePointStatus;
+    errorCode: string;
+    info?: string;
+    timestamp?: string;
+    vendorId?: string;
+    vendorErrorCode?: string;
+}
+export interface OCPP16StatusNotificationResponse {
+}
+export interface OCPP16AuthorizeRequest {
+    idTag: string;
+}
+export interface OCPP16AuthorizeResponse {
+    idTagInfo: {
+        status: 'Accepted' | 'Blocked' | 'Expired' | 'Invalid' | 'ConcurrentTx';
+        expiryDate?: string;
+        parentIdTag?: string;
+    };
+}
+export interface OCPP16StartTransactionRequest {
+    connectorId: number;
+    idTag: string;
+    meterStart: number;
+    timestamp: string;
+    reservationId?: number;
+}
+export interface OCPP16StartTransactionResponse {
+    transactionId: number;
+    idTagInfo: {
+        status: 'Accepted' | 'Blocked' | 'Expired' | 'Invalid' | 'ConcurrentTx';
+        expiryDate?: string;
+        parentIdTag?: string;
+    };
+}
+export interface OCPP16StopTransactionRequest {
+    transactionId: number;
+    timestamp: string;
+    meterStop: number;
+    idTag?: string;
+    reason?: string;
+    transactionData?: any[];
+}
+export interface OCPP16StopTransactionResponse {
+    idTagInfo?: {
+        status: 'Accepted' | 'Blocked' | 'Expired' | 'Invalid' | 'ConcurrentTx';
+        expiryDate?: string;
+        parentIdTag?: string;
+    };
+}
+export type OCPP16MeterValueContext = 'Interruption.Begin' | 'Interruption.End' | 'Sample.Clock' | 'Sample.Periodic' | 'Transaction.Begin' | 'Transaction.End' | 'Trigger';
+export type OCPP16MeterValueMeasurand = 'Voltage' | 'Current.Import' | 'Power.Active.Import' | 'SoC' | 'Power.Offered' | 'Energy.Active.Import.Register';
+export interface OCPP16MeterValueSampledValue {
+    value: string;
+    format?: 'SignedData' | 'Raw';
+    measurand: OCPP16MeterValueMeasurand;
+    context?: OCPP16MeterValueContext;
+    location?: 'Outlet' | 'EV';
+    unit: 'V' | 'A' | 'W' | 'Percent' | 'Wh';
+    phase?: 'L1' | 'L2' | 'L3';
+}
+export interface OCPP16MeterValue {
+    timestamp: string;
+    sampledValue: OCPP16MeterValueSampledValue[];
+}
+export interface OCPP16MeterValuesMessage {
+    connectorId: number;
+    transactionId: number;
+    meterValue: OCPP16MeterValue[];
+}