dt-common-device 1.0.0 → 1.0.2

package/README.md

@@ -1,73 +1,138 @@
+# dt-common-device
+
+A TypeScript library for device management, supporting both cloud and local device operations.
+
+## Installation
+
+```sh
 npm install dt-common-device
+```
 
-## Import
+## Initialization (Required)
 
-import { cloud, local, cloudInterfaces, localInterfaces } from "dt-common-device";
+Before using any service, you **must** call `initialize()` in your main entry file:
 
-## Cloud Functions
+```ts
+import { initialize } from "dt-common-device";
+
+initialize({
+  DEVICE_SERVICE: "https://api.example.com/device",
+  ADMIN_SERVICE: "https://api.example.com/admin",
+  OPERATIONAL_SERVICE: "https://api.example.com/ops",
+  MONITORING_SERVICE: "https://api.example.com/monitor",
+  // ...other config as needed
+});
+```
 
-These are stubs and must be implemented by the consuming project.
+At least one service URL must be provided.
+
+---
+
+## Importing Services
+
+### Cloud Device Service
 
 ```ts
-const connectionService = new cloud.ConnectionService();
+import { CloudDeviceService } from "dt-common-device";
 
-// Example: create a connection (must implement this in your project)
-await connectionService.createConnection(connectionData, userId);
+const cloudService = new CloudDeviceService();
 
-// Example: get device account (must implement this in your project)
-await connectionService.getDeviceAccount(connection);
+// Example: get devices (must implement in your project)
+// await cloudService.getDevices(connection);
 ```
 
-## Local Functions
-
-### DeviceService
+### Local Device Service
 
 ```ts
-const deviceService = new local.DeviceService();
+import { LocalDeviceService } from "dt-common-device";
+
+const localService = new LocalDeviceService();
 
 // Create a device
-await deviceService.createDevice(deviceBody, httpClient);
+await localService.createDevice(deviceBody);
 
 // Get a device
-const device = await deviceService.getDevice(deviceId, httpClient);
+const device = await localService.getDevice(deviceId);
 
 // Update a device
-await deviceService.updateDevice(deviceId, updateBody, httpClient);
+await localService.updateDevice(deviceId, updateBody);
 
 // Delete a device
-await deviceService.deleteDevice(deviceId, httpClient);
+await localService.deleteDevice(deviceId);
 ```
 
-## Local Functions
-
-### DeviceHubService
+### Local Device Hub Service
 
 ```ts
-const deviceHubService = new local.DeviceHubService();
+import { LocalDeviceHubService } from "dt-common-device";
+
+const deviceHubService = new LocalDeviceHubService();
 
 // Add a hub
-await deviceHubService.addHub(hubBody, httpClient);
+await deviceHubService.addHub(hubBody);
 
 // Get hubs
-const hubs = await deviceHubService.getHubs(hubIds, httpClient);
+const hubs = await deviceHubService.getHubs(hubIds);
 
 // Get a single hub
-const hub = await deviceHubService.getHub(hubId, httpClient);
+const hub = await deviceHubService.getHub(hubId);
 
 // Update a hub
-await deviceHubService.updateHub(hubId, updateBody, httpClient);
+await deviceHubService.updateHub(hubId, updateBody);
 
 // Delete a hub
-await deviceHubService.deleteHub(hubId, httpClient);
+await deviceHubService.deleteHub(hubId);
 
 // Delete multiple hubs
-await deviceHubService.deleteAllHubs(hubIds, httpClient);
+await deviceHubService.deleteAllHubs(hubIds);
 ```
 
-### Types
+---
+
+## Importing Types and Interfaces
 
 All types and interfaces are available as named exports:
 
 ```ts
-import { IDevice, IHubCreateParams } from "dt-common-device";
+import { IDevice, IHubCreateParams, IConnection } from "dt-common-device";
+```
+
+---
+
+## Notes
+
+- You **must** call `initialize()` before using any service. If not, you will get a runtime error.
+- Cloud service methods are stubs and must be implemented by the consuming project.
+- All types are strongly typed for TypeScript support.
+
+---
+
+## Example Usage
+
+```ts
+import {
+  initialize,
+  CloudDeviceService,
+  LocalDeviceService,
+  IDevice,
+} from "dt-common-device";
+
+initialize({
+  DEVICE_SERVICE: "https://api.example.com/device",
+});
+
+const cloudService = new CloudDeviceService();
+const localService = new LocalDeviceService();
+
+async function main() {
+  // Example: get devices from cloud (must implement in your project)
+  // const devices: IDevice[] = await cloudService.getDevices(connection);
+
+  // Example: create a device locally
+  await localService.createDevice({
+    /* device params */
+  });
+}
+
+main();
 ```

package/dist/config/config.d.ts

@@ -0,0 +1,3 @@
+import { DeviceConfig } from "../types";
+export declare function initialize(cfg: DeviceConfig): void;
+export declare function getConfig(): DeviceConfig;

package/dist/config/config.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = initialize;
+exports.getConfig = getConfig;
+let config = null;
+function initialize(cfg) {
+    // Check if at least one service is provided
+    const hasAtLeastOneService = [
+        "ADMIN_SERVICE",
+        "OPERATIONAL_SERVICE",
+        "DEVICE_SERVICE",
+        "MONITORING_SERVICE",
+    ].some((key) => Boolean(cfg[key]));
+    if (!hasAtLeastOneService) {
+        throw new Error("At least one http service must be initialized");
+    }
+    config = { ...cfg };
+}
+function getConfig() {
+    if (!config) {
+        throw new Error("dt-common-device: Library not initialized. Call initialize() first.");
+    }
+    return config;
+}

package/dist/device/cloud/interfaces/IDeviceConnectionService.d.ts

@@ -1,39 +1,8 @@
 import { IConnection, IConnectionConnectParams, IDevice, IDeviceAccountResponse } from "../types";
-/**
- * Class interface for device cloud operations and connection management
- */
 export interface IDeviceConnectionService {
-    /**
-     * Creates a new connection for device management
-     * @param data - Connection data
-     * @param userId - User identifier
-     * @returns Promise with connection result
-     */
     createConnection(data: IConnection, userId: string): Promise<any>;
-    /**
-     * Gets device account information for a connection
-     * @param connection - Connection object
-     * @returns Promise with device account response
-     */
     getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-    /**
-     * Gets all devices for a connection
-     * @param connection - Connection object
-     * @returns Promise with array of devices
-     */
-    getDevices(connection: IConnection): Promise<any>;
-    /**
-     * Filters devices based on connection and device list
-     * @param connection - Connection object
-     * @param devices - Array of devices to filter
-     * @returns Promise with filtered devices
-     */
-    filterDevices(connection: IConnection, devices: any[]): Promise<IDevice[]>;
-    /**
-     * Connects to a device service
-     * @param connection - Connection object
-     * @param connectionConnect - Connection parameters
-     * @returns Promise with connection result
-     */
+    getDevices(connection: IConnection): Promise<IDevice[]>;
+    filterDevices(connection: IConnection, devices: Record<string, any>[]): Promise<IDevice[]>;
     connect(connection: IConnection, connectionConnect: IConnectionConnectParams): Promise<any>;
 }

package/dist/device/cloud/interfaces/IDevicesService.d.ts

@@ -1,9 +1,9 @@
 import { IConnection } from "../types";
 export interface IDeviceService {
-    getDevices(connection: IConnection): Promise<any[]>;
-    getDevice(connectionId: string, deviceId: string): Promise<any>;
+    getDevices(connection: IConnection): Promise<Record<string, any>[]>;
+    getDevice(connectionId: string, deviceId: string): Promise<Record<string, any>>;
     getStatus(connectionId: string, deviceId: string): Promise<string | null>;
-    getState(deviceId: string): Promise<any>;
+    getState(deviceId: string): Promise<Record<string, any>>;
     getGateways(connectionId: string): Promise<any[] | null>;
     getGatewayDetails(connectionId: string, gatewayId: string): Promise<any>;
 }

package/dist/device/cloud/services/Connection.service.d.ts

@@ -1,42 +1,9 @@
 import { IDeviceConnectionService } from "../interfaces";
-import { IConnection, IConnectionConnectParams, IDevice, IDeviceAccountResponse } from "../types";
-/**
- * Device Cloud Service Class
- * Implements IDeviceCloudService interface with empty implementations
- * Implementation will be provided by the consuming project
- */
+import { IConnection, IDevice, IDeviceAccountResponse } from "../types";
 export declare class ConnectionService implements IDeviceConnectionService {
-    /**
-     * Creates a new connection for device management
-     * @param data - Connection data
-     * @param userId - User identifier
-     * @returns Promise with connection result
-     */
-    createConnection(data: IConnection, userId: string): Promise<any>;
-    /**
-     * Gets device account information for a connection
-     * @param connection - Connection object
-     * @returns Promise with device account response
-     */
+    createConnection(data: IConnection, userId: string): Promise<void>;
     getDeviceAccount(connection: IConnection): Promise<IDeviceAccountResponse>;
-    /**
-     * Gets all devices for a connection
-     * @param connection - Connection object
-     * @returns Promise with array of devices
-     */
-    getDevices(connection: IConnection): Promise<any>;
-    /**
-     * Filters devices based on connection and device list
-     * @param connection - Connection object
-     * @param devices - Array of devices to filter
-     * @returns Promise with filtered devices
-     */
-    filterDevices(connection: IConnection, devices: any[]): Promise<IDevice[]>;
-    /**
-     * Connects to a device service
-     * @param connection - Connection object
-     * @param connectionConnect - Connection parameters
-     * @returns Promise with connection result
-     */
-    connect(connection: IConnection, connectionConnect: IConnectionConnectParams): Promise<any>;
+    getDevices(connection: IConnection): Promise<IDevice[]>;
+    filterDevices(connection: IConnection, devices: Record<string, any>[]): Promise<IDevice[]>;
+    connect(connection: IConnection): Promise<void>;
 }

package/dist/device/cloud/services/Connection.service.js

@@ -1,57 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionService = void 0;
-/**
- * Device Cloud Service Class
- * Implements IDeviceCloudService interface with empty implementations
- * Implementation will be provided by the consuming project
- */
 class ConnectionService {
-    /**
-     * Creates a new connection for device management
-     * @param data - Connection data
-     * @param userId - User identifier
-     * @returns Promise with connection result
-     */
     async createConnection(data, userId) {
         // Implementation will be provided by the consuming project
         throw new Error("createConnection method not implemented");
     }
-    /**
-     * Gets device account information for a connection
-     * @param connection - Connection object
-     * @returns Promise with device account response
-     */
     async getDeviceAccount(connection) {
         // Implementation will be provided by the consuming project
         throw new Error("getDeviceAccount method not implemented");
     }
-    /**
-     * Gets all devices for a connection
-     * @param connection - Connection object
-     * @returns Promise with array of devices
-     */
     async getDevices(connection) {
         // Implementation will be provided by the consuming project
         throw new Error("getDevices method not implemented");
     }
-    /**
-     * Filters devices based on connection and device list
-     * @param connection - Connection object
-     * @param devices - Array of devices to filter
-     * @returns Promise with filtered devices
-     */
     async filterDevices(connection, devices) {
         // Implementation will be provided by the consuming project
         throw new Error("filterDevices method not implemented");
     }
-    /**
-     * Connects to a device service
-     * @param connection - Connection object
-     * @param connectionConnect - Connection parameters
-     * @returns Promise with connection result
-     */
-    async connect(connection, connectionConnect) {
+    async connect(connection) {
         // Implementation will be provided by the consuming project
         throw new Error("connect method not implemented");
     }

package/dist/device/cloud/services/Device.service.d.ts

@@ -1,10 +1,10 @@
 import { IDeviceService } from "../interfaces";
 import { IConnection } from "../types";
 export declare class DeviceService implements IDeviceService {
-    getDevices(connection: IConnection): Promise<any[]>;
+    getDevices(connection: IConnection): Promise<Record<string, any>[]>;
     getDevice(connectionId: string, deviceId: string): Promise<any>;
     getStatus(connectionId: string, deviceId: string): Promise<string | null>;
-    getState(deviceId: string): Promise<any>;
+    getState(deviceId: string): Promise<Record<string, any>>;
     getGateways(connectionId: string): Promise<any[] | null>;
-    getGatewayDetails(connectionId: string, gatewayId: string): Promise<any>;
+    getGatewayDetails(connectionId: string, gatewayId: string): Promise<Record<string, any>>;
 }

package/dist/device/cloud/services/index.d.ts

@@ -1,2 +1,3 @@
-export * from "./Connection.service";
-export * from "./Device.service";
+export { DeviceService as CloudDeviceService } from "./Device.service";
+export { ConnectionService as CloudConnectionService } from "./Connection.service";
+export { DeviceHubService as CloudDeviceHubService } from "./DeviceHub.service";

package/dist/device/cloud/services/index.js

@@ -1,19 +1,10 @@
 "use strict";
 // Device Cloud Services - Export all service classes
-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("./Connection.service"), exports);
-__exportStar(require("./Device.service"), exports);
+exports.CloudDeviceHubService = exports.CloudConnectionService = exports.CloudDeviceService = void 0;
+var Device_service_1 = require("./Device.service");
+Object.defineProperty(exports, "CloudDeviceService", { enumerable: true, get: function () { return Device_service_1.DeviceService; } });
+var Connection_service_1 = require("./Connection.service");
+Object.defineProperty(exports, "CloudConnectionService", { enumerable: true, get: function () { return Connection_service_1.ConnectionService; } });
+var DeviceHub_service_1 = require("./DeviceHub.service");
+Object.defineProperty(exports, "CloudDeviceHubService", { enumerable: true, get: function () { return DeviceHub_service_1.DeviceHubService; } });

package/dist/device/cloud/types.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Represents a connection to a device provider.
+ * WARNING: Do not log or expose sensitive fields (accessToken, clientSecret).
+ */
 export interface IConnection {
     connectionName: string;
     connectionRefId: string;
@@ -7,6 +11,14 @@ export interface IConnection {
     clientId?: string;
     clientSecret?: string;
 }
+export interface IConnectionPagination {
+    page: number;
+    limit: number;
+}
+/**
+ * Represents a device in the system.
+ * All date fields must be ISO 8601 strings.
+ */
 export interface IDevice {
     deviceId: string;
     propertyId: string;
@@ -49,8 +61,23 @@ export interface IDevice {
     };
     state?: Record<string, any>;
     metaData?: Record<string, any>;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
     hubDeviceDetails?: IDevice[];
+    parentZones?: {
+        id: string;
+        name: string;
+    }[];
+    zone?: {
+        id: string;
+        name: string;
+    };
 }
+/**
+ * Device account response from provider.
+ * WARNING: Do not log or expose connection_access_token.
+ */
 export interface IDeviceAccountResponse {
     id: string;
     connection_name: string;
@@ -63,7 +90,7 @@ export interface IDeviceAccountResponse {
 export interface IConnectionConnectParams {
     code?: string;
     propertyId?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface ConnectionProvider {
     Smartthings: "Smartthings";

package/dist/device/local/services/Device.service.d.ts

@@ -1,18 +1,10 @@
 import { IDeviceCreateParams } from "../interfaces";
 export declare class DeviceService {
-    createDevice(body: IDeviceCreateParams, httpClient: {
-        post: (url: string, options: any) => Promise<any>;
-    }): Promise<void>;
-    getDevice(deviceId: string, httpClient: {
-        get: (url: string) => Promise<any>;
-    }): Promise<any>;
-    getPropertyDevices(propertyId: string, httpClient: {
-        get: (url: string, options: any) => Promise<any>;
-    }): Promise<any>;
-    updateDevice(deviceId: string, body: any, httpClient: {
-        put: (url: string, options: any) => Promise<any>;
-    }): Promise<any>;
-    deleteDevice(deviceId: string, httpClient: {
-        delete: (url: string) => Promise<any>;
-    }): Promise<any>;
+    private readonly baseUrl;
+    constructor();
+    createDevice(body: IDeviceCreateParams): Promise<void>;
+    getDevice(deviceId: string): Promise<any>;
+    getPropertyDevices(propertyId: string): Promise<any>;
+    updateDevice(deviceId: string, body: any): Promise<any>;
+    deleteDevice(deviceId: string): Promise<any>;
 }

package/dist/device/local/services/Device.service.js

@@ -1,27 +1,36 @@
 "use strict";
 // src/device/local/services/Device.service.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../../../config/config");
 class DeviceService {
-    async createDevice(body, httpClient) {
-        // Create main device
-        await httpClient.post("/devices", { body });
+    constructor() {
+        const { DEVICE_SERVICE } = (0, config_1.getConfig)();
+        if (!DEVICE_SERVICE) {
+            throw new Error("DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE.");
+        }
+        this.baseUrl = DEVICE_SERVICE;
     }
-    async getDevice(deviceId, httpClient) {
-        return await httpClient.get(`/devices/${deviceId}`);
+    async createDevice(body) {
+        await axios_1.default.post(`${this.baseUrl}/devices`, body);
     }
-    async getPropertyDevices(propertyId, httpClient) {
-        return await httpClient.get(`/devices`, {
-            params: {
-                propertyId,
-            },
+    async getDevice(deviceId) {
+        return await axios_1.default.get(`${this.baseUrl}/devices/${deviceId}`);
+    }
+    async getPropertyDevices(propertyId) {
+        return await axios_1.default.get(`${this.baseUrl}/devices`, {
+            params: { propertyId },
         });
     }
-    async updateDevice(deviceId, body, httpClient) {
-        return await httpClient.put(`/devices/${deviceId}`, { body });
+    async updateDevice(deviceId, body) {
+        return await axios_1.default.put(`${this.baseUrl}/devices/${deviceId}`, body);
     }
-    async deleteDevice(deviceId, httpClient) {
-        return await httpClient.delete(`/devices/${deviceId}`);
+    async deleteDevice(deviceId) {
+        return await axios_1.default.delete(`${this.baseUrl}/devices/${deviceId}`);
     }
 }
 exports.DeviceService = DeviceService;

package/dist/device/local/services/DeviceHub.service.d.ts

@@ -1,21 +1,11 @@
 import { IHubCreateParams } from "../interfaces";
 export declare class DeviceHubService {
-    addHub(body: IHubCreateParams, httpClient: {
-        post: (url: string, options: any) => Promise<any>;
-    }): Promise<any>;
-    getHubs(hubIds: string[], httpClient: {
-        get: (url: string, options?: any) => Promise<any>;
-    }): Promise<any>;
-    getHub(hubId: string, httpClient: {
-        get: (url: string) => Promise<any>;
-    }): Promise<any>;
-    updateHub(hubId: string, body: any, httpClient: {
-        put: (url: string, options: any) => Promise<any>;
-    }): Promise<any>;
-    deleteHub(hubId: string, httpClient: {
-        delete: (url: string) => Promise<any>;
-    }): Promise<any>;
-    deleteAllHubs(hubIds: string[], httpClient: {
-        delete: (url: string) => Promise<any>;
-    }): Promise<any>;
+    private readonly baseUrl;
+    constructor();
+    addHub(body: IHubCreateParams): Promise<any>;
+    getHubs(hubIds: string[]): Promise<any>;
+    getHub(hubId: string): Promise<any>;
+    updateHub(hubId: string, body: any): Promise<any>;
+    deleteHub(hubId: string): Promise<any>;
+    deleteAllHubs(hubIds: string[]): Promise<any>;
 }

package/dist/device/local/services/DeviceHub.service.js

@@ -1,28 +1,40 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceHubService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../../../config/config");
 class DeviceHubService {
-    async addHub(body, httpClient) {
-        return await httpClient.post(`/devices/hubs`, { body });
+    constructor() {
+        const { DEVICE_SERVICE } = (0, config_1.getConfig)();
+        if (!DEVICE_SERVICE) {
+            throw new Error("DEVICE_SERVICE is not configured. Call initialize() first with DEVICE_SERVICE.");
+        }
+        this.baseUrl = DEVICE_SERVICE;
+    }
+    async addHub(body) {
+        return await axios_1.default.post(`${this.baseUrl}/devices/hubs`, body);
     }
     //get hubs takes an array of hub ids as query params
-    async getHubs(hubIds, httpClient) {
+    async getHubs(hubIds) {
         const query = hubIds && hubIds.length ? `?ids=${hubIds.join(",")}` : "";
-        return await httpClient.get(`/devices/hubs${query}`);
+        return await axios_1.default.get(`${this.baseUrl}/devices/hubs${query}`);
     }
     //get hub takes a hub id in params
-    async getHub(hubId, httpClient) {
-        return await httpClient.get(`/devices/hubs/${hubId}`);
+    async getHub(hubId) {
+        return await axios_1.default.get(`${this.baseUrl}/devices/hubs/${hubId}`);
     }
-    async updateHub(hubId, body, httpClient) {
-        return await httpClient.put(`/devices/hubs/${hubId}`, { body });
+    async updateHub(hubId, body) {
+        return await axios_1.default.put(`${this.baseUrl}/devices/hubs/${hubId}`, body);
     }
-    async deleteHub(hubId, httpClient) {
-        return await httpClient.delete(`/devices/hubs/${hubId}`);
+    async deleteHub(hubId) {
+        return await axios_1.default.delete(`${this.baseUrl}/devices/hubs/${hubId}`);
     }
-    async deleteAllHubs(hubIds, httpClient) {
+    async deleteAllHubs(hubIds) {
         const query = hubIds.length ? `?ids=${hubIds.join(",")}` : "";
-        return await httpClient.delete(`/devices/hubs${query}`);
+        return await axios_1.default.delete(`${this.baseUrl}/devices/hubs${query}`);
     }
 }
 exports.DeviceHubService = DeviceHubService;

package/dist/device/local/services/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./Device.service";
-export * from "./DeviceHub.service";
+export { DeviceService as LocalDeviceService } from "./Device.service";
+export { DeviceHubService as LocalDeviceHubService } from "./DeviceHub.service";

package/dist/device/local/services/index.js

@@ -1,18 +1,7 @@
 "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("./Device.service"), exports);
-__exportStar(require("./DeviceHub.service"), exports);
+exports.LocalDeviceHubService = exports.LocalDeviceService = void 0;
+var Device_service_1 = require("./Device.service");
+Object.defineProperty(exports, "LocalDeviceService", { enumerable: true, get: function () { return Device_service_1.DeviceService; } });
+var DeviceHub_service_1 = require("./DeviceHub.service");
+Object.defineProperty(exports, "LocalDeviceHubService", { enumerable: true, get: function () { return DeviceHub_service_1.DeviceHubService; } });