dt-common-device 1.3.0 → 2.0.0

package/dist/events/EventProcessingService.js

@@ -0,0 +1,243 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventProcessingService = void 0;
+const typedi_1 = require("typedi");
+const DeviceEventHandler_1 = require("./DeviceEventHandler");
+const config_1 = require("../config/config");
+const EventHandlerOrchestrator_1 = require("./EventHandlerOrchestrator");
+let EventProcessingService = (() => {
+    let _classDecorators = [(0, typedi_1.Service)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var EventProcessingService = _classThis = class {
+        constructor(deviceEventTransformerFactory) {
+            this.deviceEventTransformerFactory = deviceEventTransformerFactory;
+            this.deviceHandlers = new Map();
+            this.handlerOrchestrator = new EventHandlerOrchestrator_1.EventHandlerOrchestrator();
+            this.deviceEventHandler = new DeviceEventHandler_1.DeviceEventHandler();
+            this.logger = (0, config_1.getConfig)().LOGGER;
+            this.initializeDeviceHandlers();
+            this.initializeHandlers();
+        }
+        /**
+         * Initialize device-specific handlers - to be implemented by subclasses
+         */
+        initializeDeviceHandlers() {
+            this.deviceHandlers = new Map();
+            // Subclasses should override this method to add their specific handlers
+        }
+        /**
+         * Initialize the handler hierarchy - to be implemented by subclasses
+         */
+        initializeHandlers() {
+            try {
+                // Register generic handler for common events
+                this.handlerOrchestrator.registerHandlers([
+                    new DeviceEventHandler_1.DeviceEventHandler(), // Priority 100 - handles common events first
+                ]);
+                this.logger.info("Base event handlers initialized successfully");
+            }
+            catch (error) {
+                this.logger.error("EventProcessingService: initializeHandlers Error", error);
+            }
+        }
+        /**
+         * Get device-specific handler based on connection provider
+         */
+        getDeviceHandler(connectionProvider) {
+            const normalizedProvider = connectionProvider.toLowerCase();
+            return this.deviceHandlers.get(normalizedProvider) || null;
+        }
+        /**
+         * Transform device event using EventTransformerFactory
+         */
+        transformDeviceEventWithTransformer(connectionProvider, rawData) {
+            try {
+                // Create transformer for the connection provider
+                const transformer = this.deviceEventTransformerFactory.createTransformer(connectionProvider, rawData);
+                if (!transformer) {
+                    this.logger.warn(`No transformer found for connection provider: ${connectionProvider}`);
+                    return null;
+                }
+                // Execute the transformation pipeline
+                const transformedEvents = transformer.executeTransformation();
+                if (transformedEvents.length === 0) {
+                    this.logger.warn(`No events transformed for connection provider: ${connectionProvider}`);
+                    return null;
+                }
+                // Return the first transformed event (or handle multiple events as needed)
+                return transformedEvents[0];
+            }
+            catch (error) {
+                this.logger.error(`Error transforming event for ${connectionProvider}:`, error);
+                return null;
+            }
+        }
+        /**
+         * Transform raw event data to DeviceEvent format using EventTransformer
+         */
+        transformToDeviceEvent(connectionProvider, rawData) {
+            try {
+                // Use the transformer-based approach
+                const deviceEvent = this.transformDeviceEventWithTransformer(connectionProvider, rawData);
+                if (!deviceEvent) {
+                    this.logger.warn("Failed to transform event data using transformer", {
+                        connectionProvider,
+                        rawData,
+                    });
+                    return null;
+                }
+                this.logger.info("Transformed event using EventTransformer", {
+                    connectionProvider,
+                    originalEventName: deviceEvent.originalEventName,
+                    transformedEventName: deviceEvent.eventName,
+                    deviceId: deviceEvent.deviceId,
+                });
+                return deviceEvent;
+            }
+            catch (error) {
+                this.logger.error("EventProcessingService: transformToDeviceEvent Error", error);
+                return null;
+            }
+        }
+        /**
+         * Process a single event from device.event.controller
+         */
+        async processEvent(connectionProvider, rawData) {
+            try {
+                this.logger.info("EventProcessingService: Processing event", {
+                    connectionProvider,
+                    eventName: rawData.eventName ?? rawData.type,
+                });
+                // Transform raw data to DeviceEvent using EventTransformer
+                const deviceEvent = this.transformToDeviceEvent(connectionProvider, rawData);
+                if (!deviceEvent) {
+                    this.logger.warn("Failed to transform event data", {
+                        connectionProvider,
+                        rawData,
+                    });
+                    return;
+                }
+                // Get device-specific handler
+                const deviceHandler = this.getDeviceHandler(connectionProvider);
+                if (!deviceHandler) {
+                    this.logger.warn("No device handler found for provider", {
+                        connectionProvider,
+                    });
+                    return;
+                }
+                // Process with GenericEventHandler first (common logic)
+                if (this.deviceEventHandler.canHandle(deviceEvent.eventName)) {
+                    try {
+                        await this.deviceEventHandler.handleEvent(deviceEvent);
+                        this.logger.info("Event processed by GenericEventHandler");
+                    }
+                    catch (error) {
+                        this.logger.error("EventProcessingService: GenericEventHandler Error", error);
+                    }
+                }
+                // Process with device-specific handler
+                if (deviceHandler.canHandle(deviceEvent.eventName)) {
+                    try {
+                        await deviceHandler.onEvent(deviceEvent);
+                        this.logger.info("Event processed by device-specific handler", {
+                            handler: deviceHandler.constructor.name,
+                        });
+                    }
+                    catch (error) {
+                        this.logger.error("EventProcessingService: Device-specific handler Error", error);
+                    }
+                }
+                else {
+                    this.logger.warn("Device handler cannot handle event", {
+                        handler: deviceHandler.constructor.name,
+                        eventName: deviceEvent.eventName,
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.error("EventProcessingService: processEvent Error", error);
+                throw error;
+            }
+        }
+        /**
+         * Process a single event (legacy method for DeviceEvent objects)
+         */
+        async processEventLegacy(event) {
+            try {
+                this.logger.info("EventProcessingService: Processing legacy event", {
+                    eventName: event.eventName,
+                });
+                await this.handlerOrchestrator.processEvent(event);
+            }
+            catch (error) {
+                this.logger.error("EventProcessingService: processEventLegacy Error", error);
+                throw error;
+            }
+        }
+        /**
+         * Process multiple events
+         */
+        async processEvents(events) {
+            try {
+                this.logger.info("EventProcessingService: Processing multiple events", {
+                    count: events.length,
+                });
+                await this.handlerOrchestrator.processEvents(events);
+            }
+            catch (error) {
+                this.logger.error("EventProcessingService: processEvents Error", error);
+                throw error;
+            }
+        }
+    };
+    __setFunctionName(_classThis, "EventProcessingService");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        EventProcessingService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return EventProcessingService = _classThis;
+})();
+exports.EventProcessingService = EventProcessingService;

package/dist/events/InternalEventSubscription.d.ts

@@ -0,0 +1,44 @@
+import { IInternalEvent } from "./interfaces/IInternalEvent";
+export declare enum InternalEventType {
+    HEARTBEAT = "heartbeat",
+    SCHEDULE_CREATE = "schedule.create",
+    SCHEDULE_UPDATE = "schedule.update",
+    SCHEDULE_DELETE = "schedule.delete",
+    RESERVATION_CREATE = "reservation.create",
+    RESERVATION_UPDATE = "reservation.update",
+    RESERVATION_CANCEL = "reservation.cancel",
+    SERVICE_DOWN = "service.down"
+}
+export declare class InternalEventSubscription {
+    private readonly internalEventHandler;
+    private readonly sqsQueueUrl;
+    private readonly logger;
+    private readonly isInitialized;
+    private isSubscribed;
+    constructor(internalEventHandler: IInternalEvent);
+    private handleMessage;
+    /**
+     * Safely call handler methods with error handling
+     */
+    private safeCallHandler;
+    /**
+     * Subscribe to SQS events
+     */
+    subscribe(): Promise<void>;
+    /**
+     * Unsubscribe from SQS events
+     */
+    unsubscribe(): Promise<void>;
+    /**
+     * Get subscription status
+     */
+    getStatus(): {
+        isInitialized: boolean;
+        isSubscribed: boolean;
+        sqsUrl: string;
+    };
+    /**
+     * Check if subscription is ready
+     */
+    isReady(): boolean;
+}

package/dist/events/InternalEventSubscription.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalEventSubscription = exports.InternalEventType = void 0;
+const dt_pub_sub_1 = require("dt-pub-sub");
+const config_1 = require("../config/config");
+// Event types enum for better type safety
+var InternalEventType;
+(function (InternalEventType) {
+    InternalEventType["HEARTBEAT"] = "heartbeat";
+    InternalEventType["SCHEDULE_CREATE"] = "schedule.create";
+    InternalEventType["SCHEDULE_UPDATE"] = "schedule.update";
+    InternalEventType["SCHEDULE_DELETE"] = "schedule.delete";
+    InternalEventType["RESERVATION_CREATE"] = "reservation.create";
+    InternalEventType["RESERVATION_UPDATE"] = "reservation.update";
+    InternalEventType["RESERVATION_CANCEL"] = "reservation.cancel";
+    InternalEventType["SERVICE_DOWN"] = "service.down";
+})(InternalEventType || (exports.InternalEventType = InternalEventType = {}));
+class InternalEventSubscription {
+    constructor(internalEventHandler) {
+        this.internalEventHandler = internalEventHandler;
+        this.isInitialized = false;
+        this.isSubscribed = false;
+        this.sqsQueueUrl = (0, config_1.getConfig)().SQS_QUEUE_URL;
+        this.logger = (0, config_1.getConfig)().LOGGER;
+        this.isInitialized = true;
+    }
+    async handleMessage(message) {
+        try {
+            const eventType = message["detail-type"];
+            const eventData = message.detail;
+            this.logger.info("Received internal event", { eventType, eventData });
+            switch (eventType) {
+                case InternalEventType.HEARTBEAT:
+                    await this.safeCallHandler(() => this.internalEventHandler.onHeartbeat(eventData));
+                    break;
+                case InternalEventType.SCHEDULE_CREATE:
+                    await this.safeCallHandler(() => this.internalEventHandler.onScheduleCreate(eventData));
+                    break;
+                case InternalEventType.SCHEDULE_UPDATE:
+                    await this.safeCallHandler(() => this.internalEventHandler.onScheduleUpdate(eventData));
+                    break;
+                case InternalEventType.SCHEDULE_DELETE:
+                    await this.safeCallHandler(() => this.internalEventHandler.onScheduleDelete(eventData));
+                    break;
+                case InternalEventType.RESERVATION_CREATE:
+                    await this.safeCallHandler(() => this.internalEventHandler.onReservationCreate(eventData));
+                    break;
+                case InternalEventType.RESERVATION_UPDATE:
+                    await this.safeCallHandler(() => this.internalEventHandler.onReservationUpdate(eventData));
+                    break;
+                case InternalEventType.RESERVATION_CANCEL:
+                    await this.safeCallHandler(() => this.internalEventHandler.onReservationCancel(eventData));
+                    break;
+                case InternalEventType.SERVICE_DOWN:
+                    await this.safeCallHandler(() => this.internalEventHandler.onServiceDown(eventData));
+                    break;
+                default:
+                    this.logger.warn("Unknown event type", { eventType, eventData });
+                    break;
+            }
+        }
+        catch (error) {
+            this.logger.error("Error processing internal event message", {
+                error,
+                message,
+                eventType: message["detail-type"],
+            });
+            // Re-throw to let SQS handle retry logic
+            throw error;
+        }
+    }
+    /**
+     * Safely call handler methods with error handling
+     */
+    async safeCallHandler(handlerCall) {
+        try {
+            await handlerCall();
+        }
+        catch (error) {
+            this.logger.error("Handler method execution failed", { error });
+            // Re-throw to let the main error handler deal with it
+            throw error;
+        }
+    }
+    /**
+     * Subscribe to SQS events
+     */
+    async subscribe() {
+        if (!this.isInitialized) {
+            throw new Error("InternalEventSubscription must be initialized before subscribing");
+        }
+        if (!this.sqsQueueUrl) {
+            throw new Error("AWS SQS URL not found in environment variables");
+        }
+        if (this.isSubscribed) {
+            this.logger.warn("InternalEventSubscription is already subscribed");
+            return;
+        }
+        try {
+            await dt_pub_sub_1.eventDispatcher.subscribeToQueue(this.sqsQueueUrl, this.handleMessage.bind(this));
+            this.isSubscribed = true;
+            this.logger.info("Successfully subscribed to internal events", {
+                sqsUrl: this.sqsQueueUrl,
+            });
+        }
+        catch (error) {
+            this.logger.error("Failed to subscribe to internal events", {
+                error,
+                sqsUrl: this.sqsQueueUrl,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Unsubscribe from SQS events
+     */
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            this.logger.warn("InternalEventSubscription is not currently subscribed");
+            return;
+        }
+        try {
+            // Note: You might need to implement unsubscribe method in dt-pub-sub
+            // await eventDispatcher.unsubscribeFromQueue(this.sqsQueueUrl);
+            this.isSubscribed = false;
+            this.logger.info("Successfully unsubscribed from internal events");
+        }
+        catch (error) {
+            this.logger.error("Failed to unsubscribe from internal events", {
+                error,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get subscription status
+     */
+    getStatus() {
+        return {
+            isInitialized: this.isInitialized,
+            isSubscribed: this.isSubscribed,
+            sqsUrl: this.sqsQueueUrl,
+        };
+    }
+    /**
+     * Check if subscription is ready
+     */
+    isReady() {
+        return this.isInitialized && this.isSubscribed;
+    }
+}
+exports.InternalEventSubscription = InternalEventSubscription;

package/dist/events/index.d.ts

@@ -0,0 +1,9 @@
+export { DT_EVENT_TYPES } from "../constants/Event";
+export { EventHandler } from "./EventHandler";
+export { InternalEventSubscription } from "./InternalEventSubscription";
+export { EventProcessingService } from "./EventProcessingService";
+export { DeviceEventHandler } from "./DeviceEventHandler";
+export { EventHandlerOrchestrator } from "./EventHandlerOrchestrator";
+export { DeviceEventTransformerFactory } from "./DeviceEventTransformerFactory";
+export { BaseEventHandler } from "./BaseEventHandler";
+export { BaseEventTransformer } from "./BaseEventTransformer";

package/dist/events/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEventTransformer = exports.BaseEventHandler = exports.DeviceEventTransformerFactory = exports.EventHandlerOrchestrator = exports.DeviceEventHandler = exports.EventProcessingService = exports.InternalEventSubscription = exports.EventHandler = exports.DT_EVENT_TYPES = void 0;
+var Event_1 = require("../constants/Event");
+Object.defineProperty(exports, "DT_EVENT_TYPES", { enumerable: true, get: function () { return Event_1.DT_EVENT_TYPES; } });
+var EventHandler_1 = require("./EventHandler");
+Object.defineProperty(exports, "EventHandler", { enumerable: true, get: function () { return EventHandler_1.EventHandler; } });
+var InternalEventSubscription_1 = require("./InternalEventSubscription");
+Object.defineProperty(exports, "InternalEventSubscription", { enumerable: true, get: function () { return InternalEventSubscription_1.InternalEventSubscription; } });
+var EventProcessingService_1 = require("./EventProcessingService");
+Object.defineProperty(exports, "EventProcessingService", { enumerable: true, get: function () { return EventProcessingService_1.EventProcessingService; } });
+var DeviceEventHandler_1 = require("./DeviceEventHandler");
+Object.defineProperty(exports, "DeviceEventHandler", { enumerable: true, get: function () { return DeviceEventHandler_1.DeviceEventHandler; } });
+var EventHandlerOrchestrator_1 = require("./EventHandlerOrchestrator");
+Object.defineProperty(exports, "EventHandlerOrchestrator", { enumerable: true, get: function () { return EventHandlerOrchestrator_1.EventHandlerOrchestrator; } });
+var DeviceEventTransformerFactory_1 = require("./DeviceEventTransformerFactory");
+Object.defineProperty(exports, "DeviceEventTransformerFactory", { enumerable: true, get: function () { return DeviceEventTransformerFactory_1.DeviceEventTransformerFactory; } });
+var BaseEventHandler_1 = require("./BaseEventHandler");
+Object.defineProperty(exports, "BaseEventHandler", { enumerable: true, get: function () { return BaseEventHandler_1.BaseEventHandler; } });
+var BaseEventTransformer_1 = require("./BaseEventTransformer");
+Object.defineProperty(exports, "BaseEventTransformer", { enumerable: true, get: function () { return BaseEventTransformer_1.BaseEventTransformer; } });

package/dist/events/interfaces/DeviceEvent.d.ts

@@ -0,0 +1,48 @@
+export interface DeviceEvent {
+    eventId: string;
+    deviceId: string;
+    eventName: string;
+    data: DeviceEventData;
+    timestamp?: string;
+    connectionProvider?: string;
+    originalEventName?: string;
+    rawEvent?: any;
+}
+export interface EventConstructionOptions {
+    eventId?: string;
+    eventName?: string;
+    status?: string;
+    mode?: string;
+    userName?: string;
+    userId?: string;
+    userType?: string;
+    rawEvent?: any;
+    batteryLevel?: string;
+    reason?: string;
+    eventDescription?: string;
+}
+export interface DeviceEventEntity {
+    event: any;
+    device: any;
+    hub: any[];
+    property: any;
+}
+export interface DeviceEventData {
+    mode?: string;
+    batteryLevel?: number;
+}
+export interface TTLockEventData extends DeviceEventData {
+    label: string;
+}
+export interface SaltoKSLockEventData extends DeviceEventData {
+    userId: string;
+    deviceName: string;
+    username: string;
+    accessBy: string;
+    accessDetails: string;
+}
+export interface TuyaLockEventData extends DeviceEventData {
+}
+export interface SchlageLockEventData extends DeviceEventData {
+    event: any;
+}

package/dist/events/interfaces/DeviceEvent.js

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

package/dist/events/interfaces/IEventHandler.d.ts

@@ -0,0 +1,23 @@
+import { DeviceEvent } from "./DeviceEvent";
+export interface IEventHandler {
+    /**
+     * Handle a single transformed event
+     */
+    handleEvent(event: DeviceEvent): Promise<void>;
+    /**
+     * Handle multiple events
+     */
+    handleEvents(events: DeviceEvent[]): Promise<void>;
+    /**
+     * Check if this handler can process the given event type
+     */
+    canHandle(eventType: string): boolean;
+    /**
+     * Get the priority of this handler (lower numbers = higher priority)
+     */
+    getPriority(): number;
+    /**
+     * Get the event types this handler can process
+     */
+    getSupportedEventTypes(): string[];
+}

package/dist/events/interfaces/IEventHandler.js

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

package/dist/events/interfaces/IEventTransformer.d.ts

@@ -0,0 +1,7 @@
+import { DeviceEvent } from "./DeviceEvent";
+export interface IEventTransformer {
+    parseData(rawData: any): any;
+    transform(parsedData: any): DeviceEvent | DeviceEvent[];
+    validate(transformedEvent: DeviceEvent): boolean;
+    executeTransformation(): DeviceEvent[];
+}

package/dist/events/interfaces/IEventTransformer.js

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

package/dist/events/interfaces/IInternalEvent.d.ts

@@ -0,0 +1,42 @@
+export interface HeartbeatEventData {
+    duration?: number;
+    propertyId?: string;
+    timestamp?: string;
+    [key: string]: any;
+}
+export interface ScheduleEventData {
+    scheduleId: string;
+    propertyId: string;
+    deviceId?: string;
+    startTime: string;
+    endTime: string;
+    action: string;
+    [key: string]: any;
+}
+export interface ReservationEventData {
+    reservationId: string;
+    propertyId: string;
+    deviceId?: string;
+    userId?: string;
+    startTime: string;
+    endTime: string;
+    status: string;
+    [key: string]: any;
+}
+export interface ServiceEventData {
+    serviceId: string;
+    serviceName: string;
+    status: string;
+    timestamp: string;
+    [key: string]: any;
+}
+export interface IInternalEvent {
+    onHeartbeat(data: HeartbeatEventData): Promise<void>;
+    onScheduleCreate(data: ScheduleEventData): Promise<void>;
+    onScheduleUpdate(data: ScheduleEventData): Promise<void>;
+    onScheduleDelete(data: ScheduleEventData): Promise<void>;
+    onServiceDown(data: ServiceEventData): Promise<void>;
+    onReservationCreate(data: ReservationEventData): Promise<void>;
+    onReservationUpdate(data: ReservationEventData): Promise<void>;
+    onReservationCancel(data: ReservationEventData): Promise<void>;
+}

package/dist/events/interfaces/IInternalEvent.js

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

package/dist/events/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./IInternalEvent";
+export * from "./IEventHandler";
+export * from "./IEventTransformer";
+export * from "./DeviceEvent";

package/dist/events/interfaces/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IInternalEvent"), exports);
+__exportStar(require("./IEventHandler"), exports);
+__exportStar(require("./IEventTransformer"), exports);
+__exportStar(require("./DeviceEvent"), exports);

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 export { CloudDevice, CloudDeviceService, DeviceFactory, } from "./device/cloud/entities";
 export { LocalDeviceService, LocalHubService, LocalConnectionService, LocalPropertyService, LocalScheduleService, } from "./device/local/services";
+export * from "./events";
+export * from "./events/interfaces";
 export * from "./device/cloud/interfaces";
 export * from "./device/local/interfaces";
-export * from "./device/local/events";
-export { initialize, getConfig } from "./config/config";
+export * from "./events";
+export * from "./events/interfaces";
+export * from "./types";
+export { initialize, getConfig, shutdown } from "./config/config";