@enyo-energy/energy-app-sdk 0.0.34

package/README.md

@@ -0,0 +1,216 @@
+# enyo Energy App SDK
+
+This is the official TypeScript Energy App SDK for enyo. If you want to build your own Energy App to publish it on the enyo Hub, this is the package you need!
+
+## Installation
+
+You can install the package using npm:
+```bash
+npm install @enyo/energy-app-sdk
+```
+
+Take a look on our CLI to init a project and publish a new Energy App easily.
+
+## Usage
+
+Here's a basic example of how to use the client:
+
+```typescript
+import { EnergyApp } from '@enyo/energy-app-sdk';
+
+const energyAppInstance = new EnergyApp();
+
+energyAppInstance.register((packageName: string, version: number) => {
+    console.log(`network state is ${client.isOnline() ? 'online' : 'offline'}. Package ${packageName} version ${version} is registered.`);
+    // This starts you Energy App, do all the things in here!
+
+});
+```
+
+## Advanced Modbus Integration
+
+The SDK includes a powerful, vendor-agnostic Modbus implementation for energy management systems. This allows you to connect to any Modbus-enabled device through configuration without code changes.
+
+### ✨ Features
+
+- **Vendor Agnostic** - Works with SMA, Fronius, Huawei, or any Modbus device via configuration
+- **Type Safe** - Full TypeScript support with proper DataBus message types
+- **Configurable** - Register addresses, data types, scaling all configurable
+- **Fault Tolerant** - Built-in connection health monitoring and retry logic
+- **Modular** - Clean separation between inverters, batteries, and meters
+
+### 🚀 Quick Start
+
+#### Basic Modbus Setup
+
+```typescript
+import { EnergyApp } from '@enyo/energy-app-sdk';
+import {
+    EnergyAppModbusInverter,
+    EnergyAppModbusBattery,
+    EnergyAppModbusMeter
+} from '@enyo/energy-app-sdk';
+
+const energyApp = new EnergyApp();
+const dependencies = { client: energyApp, randomUUID: () => crypto.randomUUID() };
+
+// Network device configuration
+const networkDevice = {
+    id: 'device-1',
+    hostname: '192.168.1.100',
+    // ... other network device properties
+};
+
+// Create configurable inverter
+const modbusInverter = new EnergyAppModbusInverter(dependencies, {
+    name: [{ language: 'en', name: 'Solar Inverter' }],
+    registers: {
+        serialNumber: {
+            address: 400001,
+            dataType: 'uint16'
+        },
+        power: {
+            address: 400010,
+            dataType: 'int32',
+            required: true
+        },
+        voltageL1: {
+            address: 400020,
+            dataType: 'uint32',
+            scale: 2
+        },
+        totalEnergy: {
+            address: 400030,
+            dataType: 'uint32'
+        }
+    },
+    options: {
+        unitId: 1,
+        timeout: 5000
+    }
+}, networkDevice);
+
+// Create battery with inverter dependency
+const modbusBattery = new EnergyAppModbusBattery(dependencies, {
+    inverter: modbusInverter,
+    name: [{ language: 'en', name: 'Battery Storage' }],
+    registers: {
+        soc: {
+            address: 500001,
+            dataType: 'uint16',
+            required: true
+        },
+        current: {
+            address: 500005,
+            dataType: 'int16',
+            scale: 1
+        },
+        voltage: {
+            address: 500010,
+            dataType: 'uint16',
+            scale: 1
+        }
+    },
+    options: {}
+});
+
+// Create standalone meter
+const modbusMeter = new EnergyAppModbusMeter(dependencies, {
+    name: [{ language: 'en', name: 'Grid Meter' }],
+    registers: {
+        gridPower: {
+            address: 600001,
+            dataType: 'int32',
+            required: true
+        },
+        gridFeedInEnergy: {
+            address: 600010,
+            dataType: 'uint32'
+        },
+        gridConsumptionEnergy: {
+            address: 600020,
+            dataType: 'uint32'
+        }
+    },
+    options: {
+        unitId: 2
+    }
+}, networkDevice);
+
+// Connect and start data collection
+await modbusInverter.connect();
+await modbusBattery.connect();
+await modbusMeter.connect();
+
+// Fetch data (returns proper DataBus messages)
+const inverterData = await modbusInverter.updateData();
+const batteryData = await modbusBattery.updateData();
+const meterData = await modbusMeter.updateData();
+```
+
+### 📊 Supported Data Types
+
+- `uint16` - 16-bit unsigned integer (1 register)
+- `int16` - 16-bit signed integer (1 register)
+- `uint32` - 32-bit unsigned integer (2 registers)
+- `int32` - 32-bit signed integer (2 registers)
+- `float32` - 32-bit float (2 registers)
+
+### ⚙️ Register Configuration
+
+```typescript
+interface EnergyAppModbusRegisterConfig {
+    address: number;                    // Modbus register address
+    dataType: EnergyAppModbusDataType;  // Data type
+    scale?: number;                     // Scaling factor (FIX2 = scale 2)
+    quantity?: number;                  // Number of registers (auto-calculated)
+    required?: boolean;                 // Whether register is required
+}
+```
+
+### 🔄 DataBus Integration
+
+The Modbus implementation seamlessly integrates with the enyo DataBus using typed messages:
+
+- `EnyoDataBusInverterValuesV1` - Inverter data messages
+- `EnyoDataBusBatteryValuesUpdateV1` - Battery data messages
+- `EnyoDataBusMeterValuesUpdateV1` - Meter data messages
+
+All messages include proper timestamps and message types for seamless integration with the enyo platform.
+
+### 🛠️ Error Handling
+
+The implementation provides comprehensive error handling with specific error types:
+
+- **EnergyAppModbusConfigurationError** - Invalid configuration parameters
+- **EnergyAppModbusConnectionError** - Connection and communication failures
+- **EnergyAppModbusReadError** - Register read failures with context
+
+```typescript
+try {
+    await modbusInverter.connect();
+    const data = await modbusInverter.updateData();
+} catch (error) {
+    if (error instanceof EnergyAppModbusConnectionError) {
+        console.error('Connection failed:', error.message);
+        // Handle connection issues
+    } else if (error instanceof EnergyAppModbusConfigurationError) {
+        console.error('Configuration error:', error.message);
+        // Fix configuration issues
+    }
+}
+```
+
+### 🏗️ Architecture
+
+The Modbus implementation follows a clean, modular architecture:
+
+- **EnergyAppModbusInverter** - Configurable inverter implementation
+- **EnergyAppModbusBattery** - Battery with inverter dependency support
+- **EnergyAppModbusMeter** - Standalone meter implementation
+- **EnergyAppModbusRegisterMapper** - Configuration-driven register access
+- **EnergyAppModbusDataTypeConverter** - Vendor-agnostic data handling
+- **EnergyAppModbusFaultTolerantReader** - Fault-tolerant communication layer
+- **EnergyAppModbusConnectionHealth** - Connection health monitoring
+
+This modular design ensures maintainability, testability, and extensibility for future enhancements.

package/dist/cjs/connect-ems-api.cjs

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

package/dist/cjs/connect-ems-api.d.cts

@@ -0,0 +1,30 @@
+import { ConnectInterval } from "./packages/connect-interval.cjs";
+import { ConnectModbus } from "./packages/connect-modbus.cjs";
+import { ConnectNetworkDevices } from "./packages/connect-network-devices.cjs";
+import { ConnectStorage } from "./packages/connect-storage.cjs";
+import { ConnectAppliances } from "./packages/connect-appliance.cjs";
+/**
+ * Main API interface for Connect EMS packages.
+ * Provides access to all system capabilities including lifecycle management,
+ * network operations, storage, and device communication.
+ */
+export interface ConnectEmsApi {
+    /** Register a callback that gets called when the package is initialized */
+    register: (callback: (packageName: string, version: number) => void) => void;
+    /** Register a callback that gets called when the system is shutting down */
+    onShutdown: (callback: () => Promise<void>) => void;
+    /** Check if the system is currently online */
+    isOnline: () => boolean;
+    /** Get the fetch API for HTTP requests */
+    useFetch: () => typeof fetch;
+    /** Get the interval management API */
+    useInterval: () => ConnectInterval;
+    /** Get the Modbus communication API */
+    useModbus: () => ConnectModbus;
+    /** Get the network device discovery API */
+    useNetworkDevices: () => ConnectNetworkDevices;
+    /** Get the persistent storage API */
+    useStorage: () => ConnectStorage;
+    /** Get the Appliance API */
+    useAppliances: () => ConnectAppliances;
+}

package/dist/cjs/connect-ems-permission.enum.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectEmsPermissionEnum = void 0;
+var ConnectEmsPermissionEnum;
+(function (ConnectEmsPermissionEnum) {
+    ConnectEmsPermissionEnum["RestrictedInternetAccess"] = "RestrictedInternetAccess";
+})(ConnectEmsPermissionEnum || (exports.ConnectEmsPermissionEnum = ConnectEmsPermissionEnum = {}));

package/dist/cjs/connect-ems-permission.enum.d.cts

@@ -0,0 +1,3 @@
+export declare enum ConnectEmsPermissionEnum {
+    RestrictedInternetAccess = "RestrictedInternetAccess"
+}

package/dist/cjs/connect-ems-permission.type.cjs

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

package/dist/cjs/connect-ems-permission.type.d.cts

@@ -0,0 +1 @@
+export type ConnectEmsPermissionType = 'RestrictedInternetAccess' | 'NetworkDeviceDiscovery' | 'NetworkDeviceSearch' | 'Modbus';

package/dist/cjs/connect-package-definition.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectPackageCategory = void 0;
+exports.defineConnectEmsPackage = defineConnectEmsPackage;
+var ConnectPackageCategory;
+(function (ConnectPackageCategory) {
+    ConnectPackageCategory["Inverter"] = "inverter";
+    ConnectPackageCategory["Wallbox"] = "wallbox";
+    ConnectPackageCategory["Meter"] = "meter";
+    ConnectPackageCategory["SmartControl"] = "smart-control";
+})(ConnectPackageCategory || (exports.ConnectPackageCategory = ConnectPackageCategory = {}));
+function defineConnectEmsPackage(definition) {
+    return definition;
+}

package/dist/cjs/connect-package-definition.d.cts

@@ -0,0 +1,57 @@
+import { ConnectEmsPermissionType } from "./connect-ems-permission.type.cjs";
+export type ConnectPackageLanguage = 'de' | 'en';
+export declare enum ConnectPackageCategory {
+    Inverter = "inverter",
+    Wallbox = "wallbox",
+    Meter = "meter",
+    SmartControl = "smart-control"
+}
+/**
+ * Configuration options for restricting internet access in a Connect EMS package.
+ * Defines which internet origins (domains) the EMS Integration is allowed to access.
+ */
+export interface ConnectPackageRestrictedInternetAccessOption {
+    /** List of allowed internet origins (domains) that the EMS Integration can access. Only these origins will be accessible. This information is shown to the user */
+    origins: string[];
+}
+/**
+ * Optional configuration settings for a Connect EMS package.
+ */
+export interface ConnectPackageOptions {
+    /** Configuration for restricting internet access to specific domains */
+    restrictedInternetAccess?: ConnectPackageRestrictedInternetAccessOption;
+}
+/**
+ * Localized store entry information for a Connect EMS package.
+ * Contains all the display information shown to users in the package store.
+ */
+export interface ConnectPackageStoreEntry {
+    /** Language code for this store entry */
+    language: ConnectPackageLanguage;
+    /** Display title of the package */
+    title: string;
+    /** Brief description shown in package listings */
+    shortDescription: string;
+    /** Detailed description of the package functionality */
+    description: string;
+}
+/**
+ * Complete definition for a Connect EMS package.
+ * This interface defines all the metadata, permissions, and configuration
+ * required to register a package with the Connect EMS system.
+ */
+export interface ConnectPackageDefinition {
+    /** Schema version for the package definition format */
+    version: '1';
+    /** Unique identifier for the package */
+    packageName: string;
+    /** Categories that this package belongs to */
+    categories: ConnectPackageCategory[];
+    /** Localized store information for different languages */
+    storeEntry: ConnectPackageStoreEntry[];
+    /** Required permissions for this package to function */
+    permissions: ConnectEmsPermissionType[];
+    /** Optional configuration settings */
+    options?: ConnectPackageOptions;
+}
+export declare function defineConnectEmsPackage(definition: ConnectPackageDefinition): ConnectPackageDefinition;

package/dist/cjs/energy-app-appliance-type.enum.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnergyAppApplianceTypeEnum = void 0;
+var EnergyAppApplianceTypeEnum;
+(function (EnergyAppApplianceTypeEnum) {
+    EnergyAppApplianceTypeEnum["Inverter"] = "Inverter";
+    EnergyAppApplianceTypeEnum["Charger"] = "Charger";
+    EnergyAppApplianceTypeEnum["Storage"] = "Storage";
+    EnergyAppApplianceTypeEnum["Meter"] = "Meter";
+    EnergyAppApplianceTypeEnum["HeatPump"] = "heat-pump";
+    EnergyAppApplianceTypeEnum["EnergyManagement"] = "energy-management";
+    EnergyAppApplianceTypeEnum["BatteryStorage"] = "battery-storage";
+    EnergyAppApplianceTypeEnum["ClimateControl"] = "climate-control";
+})(EnergyAppApplianceTypeEnum || (exports.EnergyAppApplianceTypeEnum = EnergyAppApplianceTypeEnum = {}));

package/dist/cjs/energy-app-appliance-type.enum.d.cts

@@ -0,0 +1,10 @@
+export declare enum EnergyAppApplianceTypeEnum {
+    Inverter = "Inverter",
+    Charger = "Charger",
+    Storage = "Storage",
+    Meter = "Meter",
+    HeatPump = "heat-pump",
+    EnergyManagement = "energy-management",
+    BatteryStorage = "battery-storage",
+    ClimateControl = "climate-control"
+}

package/dist/cjs/energy-app-package-configuration.cjs

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

package/dist/cjs/energy-app-package-configuration.d.cts

@@ -0,0 +1,30 @@
+import { EnergyAppPackageLanguage } from "./energy-app-package-definition.cjs";
+export interface EnergyAppPackageConfigurationTranslatedValue {
+    /** Language code */
+    language: EnergyAppPackageLanguage;
+    /** The displayed value */
+    value: string;
+}
+export interface EnergyAppPackageConfigurationSettingSelectOption {
+    value: string;
+    /** The displayed name of the option */
+    optionName: EnergyAppPackageConfigurationTranslatedValue[];
+}
+export interface EnergyAppPackageConfigurationSetting {
+    /** internal name of the setting */
+    name: string;
+    /** the type of the setting */
+    type: 'text' | 'select';
+    /** if the setting is required */
+    required: boolean;
+    /** The displayed name of the field */
+    fieldName: EnergyAppPackageConfigurationTranslatedValue[];
+    /** An optional description for the user*/
+    fieldDescription?: EnergyAppPackageConfigurationTranslatedValue[];
+    /** The optional default value or default selection value*/
+    defaultValue?: string;
+    selectOptions?: EnergyAppPackageConfigurationSettingSelectOption[];
+}
+export interface EnergyAppPackageConfiguration {
+    settings?: EnergyAppPackageConfigurationSetting[];
+}

package/dist/cjs/energy-app-package-definition.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnergyAppPackageCategory = void 0;
+exports.defineEnergyAppPackage = defineEnergyAppPackage;
+const version_js_1 = require("./version.cjs");
+var EnergyAppPackageCategory;
+(function (EnergyAppPackageCategory) {
+    EnergyAppPackageCategory["Inverter"] = "inverter";
+    EnergyAppPackageCategory["Wallbox"] = "wallbox";
+    EnergyAppPackageCategory["Meter"] = "meter";
+    EnergyAppPackageCategory["EnergyManagement"] = "energy-management";
+    EnergyAppPackageCategory["HeatPump"] = "heat-pump";
+    EnergyAppPackageCategory["BatteryStorage"] = "battery-storage";
+    EnergyAppPackageCategory["ClimateControl"] = "climate-control";
+    EnergyAppPackageCategory["ElectricityTariff"] = "electricity-tariff";
+})(EnergyAppPackageCategory || (exports.EnergyAppPackageCategory = EnergyAppPackageCategory = {}));
+/**
+ * Defines an Energy App package with automatic SDK version injection.
+ * This function automatically adds the current SDK version to the package definition
+ * for debugging and compatibility tracking purposes.
+ *
+ * @param definition The Energy App package definition
+ * @returns The enhanced package definition with SDK version included
+ */
+function defineEnergyAppPackage(definition) {
+    return {
+        ...definition,
+        sdkVersion: (0, version_js_1.getSdkVersion)()
+    };
+}

package/dist/cjs/energy-app-package-definition.d.cts

@@ -0,0 +1,123 @@
+import { EnergyAppPermissionType } from "./energy-app-permission.type.cjs";
+export type EnergyAppPackageLanguage = 'de' | 'en';
+export declare enum EnergyAppPackageCategory {
+    Inverter = "inverter",
+    Wallbox = "wallbox",
+    Meter = "meter",
+    EnergyManagement = "energy-management",
+    HeatPump = "heat-pump",
+    BatteryStorage = "battery-storage",
+    ClimateControl = "climate-control",
+    ElectricityTariff = "electricity-tariff"
+}
+/**
+ * Configuration options for restricting internet access in an Energy App package.
+ * Defines which internet origins (domains) the Energy App is allowed to access.
+ */
+export interface EnergyAppPackageRestrictedInternetAccessOption {
+    /** List of allowed internet origins (domains) that the Energy App can access. Only these origins will be accessible. This information is shown to the user */
+    origins: string[];
+}
+/**
+ * Optional device detection configuration for hostname detection. The check is always lower case string
+ */
+export interface EnergyAppPackageOptionsDeviceDetectionHostname {
+    operation: 'eq' | 'startsWith';
+    matchingValue: string;
+}
+export interface EnergyAppPackageOptionsDeviceDetectionModbus {
+    unitIds: number[];
+    /** Register address, for example 30001 */
+    registerAddress: number;
+    /** Register size, for example 2 for 30001 - 30002 */
+    registerSize: number;
+    /** the data type of the register, numbers will be mapped to strings to compare with matching values */
+    type: 'string' | 'UInt32BE' | 'UInt16BE' | 'UInt32LE' | 'UInt16LE';
+    /** matching values, for example the vendor names or model names */
+    matchingValues: string[];
+}
+export interface EnergyAppPackageOptionsDeviceDetectionHttp {
+    /** port of http call */
+    port: number;
+    /** path of http call */
+    path: string;
+    /** the operation to do */
+    operation: 'body_json_field_eq' | 'header_eq' | 'header_startsWith';
+    /** for rest APIs with json response, define the field for example device.vendor*/
+    field?: string;
+    headerName?: string;
+    /** matching values, for example the vendor names or model names */
+    matchingValues: string[];
+}
+export interface EnergyAppPackageOptionsDeviceDetectionOcpp {
+    /** ocpp message name, for example BootNotification */
+    message: string;
+    /** field name in the boot notification */
+    field: string;
+    /** matching values, for example the vendor names or model names */
+    matchingValues: string[];
+}
+/**
+ * Optional device detection configuration
+ */
+export interface EnergyAppPackageOptionsDeviceDetection {
+    hostName?: EnergyAppPackageOptionsDeviceDetectionHostname[];
+    modbus?: EnergyAppPackageOptionsDeviceDetectionModbus[];
+    http?: EnergyAppPackageOptionsDeviceDetectionHttp[];
+    ocpp?: EnergyAppPackageOptionsDeviceDetectionOcpp[];
+}
+/**
+ * Optional configuration settings for an Energy App package.
+ */
+export interface EnergyAppPackageOptions {
+    /** Configuration for restricting internet access to specific domains */
+    restrictedInternetAccess?: EnergyAppPackageRestrictedInternetAccessOption;
+    /** device detection configuration to auto-suggest this energy app on onboarding */
+    deviceDetection?: EnergyAppPackageOptionsDeviceDetection;
+}
+/**
+ * Localized store entry information for an Energy App package.
+ * Contains all the display information shown to users in the package store.
+ */
+export interface EnergyAppPackageStoreEntry {
+    /** Language code for this store entry */
+    language: EnergyAppPackageLanguage;
+    /** Display title of the package */
+    title: string;
+    /** Brief description shown in package listings */
+    shortDescription: string;
+    /** Detailed description of the package functionality */
+    description: string;
+}
+/**
+ * Complete definition for a enyo Energy App package.
+ * This interface defines all the metadata, permissions, and configuration
+ * required to register a package with the enyo Hub.
+ */
+export interface EnergyAppPackageDefinition {
+    /** Schema version for the package definition format */
+    version: '1';
+    /** Unique identifier for the package */
+    packageName: string;
+    /** Optional path to the logo */
+    logo?: string;
+    /** Categories that this package belongs to */
+    categories: EnergyAppPackageCategory[];
+    /** Localized store information for different languages */
+    storeEntry: EnergyAppPackageStoreEntry[];
+    /** Required permissions for this package to function */
+    permissions: EnergyAppPermissionType[];
+    /** Optional configuration settings */
+    options?: EnergyAppPackageOptions;
+    /** The version of the enyo SDK used to build this package (automatically injected) */
+    sdkVersion: string;
+}
+/**
+ * Defines an Energy App package with automatic SDK version injection.
+ * This function automatically adds the current SDK version to the package definition
+ * for debugging and compatibility tracking purposes.
+ *
+ * @param definition The Energy App package definition
+ * @returns The enhanced package definition with SDK version included
+ */
+export declare function defineEnergyAppPackage(definition: Omit<EnergyAppPackageDefinition, 'sdkVersion'>): EnergyAppPackageDefinition;

package/dist/cjs/energy-app-permission.type.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnergyAppPermissionTypeEnum = void 0;
+var EnergyAppPermissionTypeEnum;
+(function (EnergyAppPermissionTypeEnum) {
+    EnergyAppPermissionTypeEnum["RestrictedInternetAccess"] = "RestrictedInternetAccess";
+    EnergyAppPermissionTypeEnum["NetworkDeviceDiscovery"] = "NetworkDeviceDiscovery";
+    EnergyAppPermissionTypeEnum["NetworkDeviceSearch"] = "NetworkDeviceSearch";
+    EnergyAppPermissionTypeEnum["NetworkDeviceAccess"] = "NetworkDeviceAccess";
+    EnergyAppPermissionTypeEnum["Modbus"] = "Modbus";
+    EnergyAppPermissionTypeEnum["Storage"] = "Storage";
+    EnergyAppPermissionTypeEnum["Appliance"] = "Appliance";
+    EnergyAppPermissionTypeEnum["AllAppliances"] = "AllAppliances";
+    EnergyAppPermissionTypeEnum["SendDataBusValues"] = "SendDataBusValues";
+    EnergyAppPermissionTypeEnum["SubscribeDataBus"] = "SubscribeDataBus";
+    EnergyAppPermissionTypeEnum["SendDataBusCommands"] = "SendDataBusCommands";
+    EnergyAppPermissionTypeEnum["OcppServer"] = "OcppServer";
+    EnergyAppPermissionTypeEnum["ChargingCard"] = "ChargingCard";
+    EnergyAppPermissionTypeEnum["Vehicle"] = "Vehicle";
+    EnergyAppPermissionTypeEnum["Charge"] = "Charge";
+})(EnergyAppPermissionTypeEnum || (exports.EnergyAppPermissionTypeEnum = EnergyAppPermissionTypeEnum = {}));

package/dist/cjs/energy-app-permission.type.d.cts

@@ -0,0 +1,18 @@
+export type EnergyAppPermissionType = 'RestrictedInternetAccess' | 'NetworkDeviceDiscovery' | 'NetworkDeviceSearch' | 'NetworkDeviceAccess' | 'Modbus' | 'Storage' | 'Appliance' | 'AllAppliances' | 'SendDataBusValues' | 'SubscribeDataBus' | 'SendDataBusCommands' | 'OcppServer';
+export declare enum EnergyAppPermissionTypeEnum {
+    RestrictedInternetAccess = "RestrictedInternetAccess",
+    NetworkDeviceDiscovery = "NetworkDeviceDiscovery",
+    NetworkDeviceSearch = "NetworkDeviceSearch",
+    NetworkDeviceAccess = "NetworkDeviceAccess",
+    Modbus = "Modbus",
+    Storage = "Storage",
+    Appliance = "Appliance",
+    AllAppliances = "AllAppliances",
+    SendDataBusValues = "SendDataBusValues",
+    SubscribeDataBus = "SubscribeDataBus",
+    SendDataBusCommands = "SendDataBusCommands",
+    OcppServer = "OcppServer",
+    ChargingCard = "ChargingCard",
+    Vehicle = "Vehicle",
+    Charge = "Charge"
+}

package/dist/cjs/enyo-energy-app-sdk.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnergyAppStateEnum = void 0;
+var EnergyAppStateEnum;
+(function (EnergyAppStateEnum) {
+    EnergyAppStateEnum["Launching"] = "launching";
+    EnergyAppStateEnum["Running"] = "running";
+    /** This state tells the user that a configuration is required which blocks the energy app from running*/
+    EnergyAppStateEnum["ConfigurationRequired"] = "configuration-required";
+    /** This state tells the user that an internet connection of the system is required which blocks the energy app from running*/
+    EnergyAppStateEnum["InternetConnectionRequired"] = "internet-connection-required";
+})(EnergyAppStateEnum || (exports.EnergyAppStateEnum = EnergyAppStateEnum = {}));