dt-common-device 13.0.25 → 13.0.26

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

@@ -0,0 +1,39 @@
+import { IDeviceService } from "../interfaces";
+import { IConnection, IDevice } from "../types";
+export declare abstract class DeviceService implements IDeviceService {
+    deviceId: string;
+    propertyId: string;
+    name: string;
+    hubId: string[];
+    deviceType: {
+        id: string;
+        type: string;
+    };
+    status: {
+        online: boolean;
+        error?: {
+            type?: string;
+            message?: string;
+        };
+        lastUpdated?: string;
+    };
+    state?: Record<string, any>;
+    metaData?: Record<string, any>;
+    zone?: {
+        id: string;
+        name: string;
+        zoneType: string;
+        parentZone?: {
+            id: string;
+            name: string;
+            zoneType: string;
+        };
+    };
+    connection: IConnection;
+    constructor(device: IDevice);
+    abstract getDevices(connection: IConnection): Promise<Record<string, any>[]>;
+    abstract getDevice(connectionId: string, deviceId: string): Promise<any>;
+    abstract getBattery(deviceId: string): Promise<number | string>;
+    abstract getStatus(connectionId: string, deviceId: string): Promise<string>;
+    abstract getState(deviceId: string): Promise<string>;
+}

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

@@ -0,0 +1,42 @@
+import { IDeviceCloudService } from "../interface";
+import { IConnection, IDevice, IDeviceAccountResponse, IConnectionConnectParams } from "../types";
+/**
+ * Device Cloud Service Class
+ * Implements IDeviceCloudService interface with empty implementations
+ * Implementation will be provided by the consuming project
+ */
+export declare class DeviceCloudService implements IDeviceCloudService {
+    /**
+     * 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<IDevice[]>;
+    /**
+     * 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>;
+}

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

@@ -0,0 +1,3 @@
+export declare abstract class DeviceHubService {
+    abstract getHubs(): Promise<any>;
+}

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

@@ -0,0 +1,25 @@
+import { IHubService } from "../interfaces";
+import { IConnection, IDevice } from "../types";
+export declare abstract class HubService implements IHubService {
+    deviceId: string;
+    propertyId: string;
+    name: string;
+    deviceType: {
+        id: string;
+        type: string;
+    };
+    status: {
+        online: boolean;
+        error?: {
+            type?: string;
+            message?: string;
+        };
+        lastUpdated?: string;
+    };
+    metaData?: Record<string, any>;
+    connection: IConnection;
+    constructor(hub: IDevice);
+    abstract getHubs(connectionId: string): Promise<any[] | null>;
+    abstract getHub(connectionId: string, hubId: string): Promise<Record<string, any>>;
+    abstract getStatus(connectionId: string, hubId: string): Promise<string>;
+}

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

@@ -0,0 +1,38 @@
+import { ISmartthingsDeviceCommandManager } from "../interface";
+import { IDeviceCommand, ISmartthingsDeviceCommand, ICommandResponse } from "../types";
+/**
+ * SmartThings Device Service Class
+ * Implements ISmartthingsDeviceCommandManager interface with empty implementations
+ * Implementation will be provided by the consuming project
+ */
+export declare class SmartThingsDeviceService implements ISmartthingsDeviceCommandManager {
+    /**
+     * Invokes a command on a device
+     * @param command - Device command to execute
+     * @param deviceId - Device identifier
+     * @returns Promise with command response
+     */
+    invokeCommand(command: IDeviceCommand, deviceId: string): Promise<ICommandResponse>;
+    /**
+     * Performs device action for SmartThings
+     * @param commands - Array of SmartThings device commands
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with action result
+     */
+    performDeviceAction(commands: ISmartthingsDeviceCommand[], deviceId: string, accessToken: string): Promise<any>;
+    /**
+     * Gets device status for SmartThings
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with device status
+     */
+    getDeviceStatus(deviceId: string, accessToken: string): Promise<any>;
+    /**
+     * Gets device lock status for SmartThings
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with lock status
+     */
+    getDeviceLockStatus(deviceId: string, accessToken: string): Promise<any>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartThingsDeviceService = void 0;
+/**
+ * SmartThings Device Service Class
+ * Implements ISmartthingsDeviceCommandManager interface with empty implementations
+ * Implementation will be provided by the consuming project
+ */
+class SmartThingsDeviceService {
+    /**
+     * Invokes a command on a device
+     * @param command - Device command to execute
+     * @param deviceId - Device identifier
+     * @returns Promise with command response
+     */
+    async invokeCommand(command, deviceId) {
+        // Implementation will be provided by the consuming project
+        throw new Error("invokeCommand method not implemented");
+    }
+    /**
+     * Performs device action for SmartThings
+     * @param commands - Array of SmartThings device commands
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with action result
+     */
+    async performDeviceAction(commands, deviceId, accessToken) {
+        // Implementation will be provided by the consuming project
+        throw new Error("performDeviceAction method not implemented");
+    }
+    /**
+     * Gets device status for SmartThings
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with device status
+     */
+    async getDeviceStatus(deviceId, accessToken) {
+        // Implementation will be provided by the consuming project
+        throw new Error("getDeviceStatus method not implemented");
+    }
+    /**
+     * Gets device lock status for SmartThings
+     * @param deviceId - Device identifier
+     * @param accessToken - Access token for authentication
+     * @returns Promise with lock status
+     */
+    async getDeviceLockStatus(deviceId, accessToken) {
+        // Implementation will be provided by the consuming project
+        throw new Error("getDeviceLockStatus method not implemented");
+    }
+}
+exports.SmartThingsDeviceService = SmartThingsDeviceService;

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

@@ -0,0 +1,2 @@
+export * from "./CloudDevice.service";
+export * from "./Connection.service";

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

@@ -0,0 +1,52 @@
+/**
+ * Represents a connection to a device provider.
+ * WARNING: Do not log or expose sensitive fields (accessToken, clientSecret).
+ */
+export interface IConnection {
+    id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
+    connectionName: string;
+    connectionRefId: string;
+    propertyId: string;
+    connectionProvider: ConnectionProvider;
+    accessToken?: string;
+    refreshToken?: string;
+    clientId?: string;
+    clientSecret: string;
+    isActive?: boolean;
+    metaData?: any;
+}
+export interface IConnectionPagination {
+    page: number;
+    limit: number;
+}
+/**
+ * Device account response from provider.
+ * WARNING: Do not log or expose connection_access_token.
+ */
+export interface IDeviceAccountResponse {
+    id: string;
+    connection_name: string;
+    connection_access_token: string;
+    connection_provider: string;
+    totalDevices: number;
+    connection_ref_id: string;
+    isActive: boolean;
+}
+export interface IConnectionConnectParams {
+    code?: string;
+    propertyId?: string;
+    [key: string]: unknown;
+}
+export declare enum ConnectionProvider {
+    Smartthings = "Smartthings",
+    SaltoKS = "SaltoKS",
+    TTLock = "TTLock",
+    Tuya = "Tuya",
+    Schlage = "Schlage",
+    YaleWifi = "YaleWifi",
+    Sensibo = "Sensibo",
+    Devicethread = "Devicethread"
+}

package/dist/device/cloud/types.js

@@ -0,0 +1,15 @@
+"use strict";
+// Device Cloud Type Interfaces for DeviceThread Common Library
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionProvider = void 0;
+var ConnectionProvider;
+(function (ConnectionProvider) {
+    ConnectionProvider["Smartthings"] = "Smartthings";
+    ConnectionProvider["SaltoKS"] = "SaltoKS";
+    ConnectionProvider["TTLock"] = "TTLock";
+    ConnectionProvider["Tuya"] = "Tuya";
+    ConnectionProvider["Schlage"] = "Schlage";
+    ConnectionProvider["YaleWifi"] = "YaleWifi";
+    ConnectionProvider["Sensibo"] = "Sensibo";
+    ConnectionProvider["Devicethread"] = "Devicethread";
+})(ConnectionProvider || (exports.ConnectionProvider = ConnectionProvider = {}));

package/dist/device/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./cloud/interface";
+export * from "./cloud/types";
+export type { IConnection, IConnectionConnectParams, IDevice, IDeviceAccountResponse, } from "./cloud/types";
+export type { IDeviceCloudService } from "./cloud/interface";

package/dist/device/local/entities/AlertBuilder.d.ts

@@ -0,0 +1,87 @@
+import { CreateAlertData, AlertCategory, AlertSeverity, EntityType } from "../../../types/alert.types";
+/**
+ * AlertBuilder - A builder pattern implementation for constructing CreateAlertData objects
+ *
+ * This builder provides a fluent interface for creating alert data with proper validation
+ * and default values. It follows the Builder pattern which is a standard design pattern
+ * in TypeScript for constructing complex objects.
+ *
+ * Usage example:
+ * const alertData = new AlertBuilder()
+ *   .setCategory(AlertCategory.OPERATIONS)
+ *   .setPropertyId("prop123")
+ *   .setTitle("Device Offline")
+ *   .setDescription("Device has been offline for more than 5 minutes")
+ *   .setEntityId("device456")
+ *   .setEntityType(EntityType.DEVICE)
+ *   .setSeverity(AlertSeverity.HIGH)
+ *   .setCreatedBy("user789")
+ *   .build();
+ */
+export declare class AlertBuilder {
+    private data;
+    /**
+     * Sets the alert category
+     */
+    setCategory(category: AlertCategory): AlertBuilder;
+    /**
+     * Sets the property ID
+     */
+    setPropertyId(propertyId: string): AlertBuilder;
+    /**
+     * Sets the alert title
+     */
+    setTitle(title: string): AlertBuilder;
+    /**
+     * Sets the alert description
+     */
+    setDescription(description: string): AlertBuilder;
+    /**
+     * Sets the entity ID (optional)
+     */
+    setEntityId(entityId?: string): AlertBuilder;
+    /**
+     * Sets the entity type
+     */
+    setEntityType(entityType: EntityType): AlertBuilder;
+    /**
+     * Sets the alert severity (optional, defaults to MEDIUM)
+     */
+    setSeverity(severity?: AlertSeverity): AlertBuilder;
+    /**
+     * Sets the user who created the alert (optional)
+     */
+    setCreatedBy(createdBy?: string): AlertBuilder;
+    /**
+     * Sets the snooze until date (optional)
+     */
+    setSnoozeUntil(snoozeUntil?: Date): AlertBuilder;
+    /**
+     * Validates that all required fields are present
+     */
+    private validate;
+    /**
+     * Builds and returns the CreateAlertData object
+     * @throws Error if required fields are missing
+     */
+    build(): CreateAlertData;
+    /**
+     * Resets the builder to its initial state
+     */
+    reset(): AlertBuilder;
+    /**
+     * Creates a new builder instance with predefined values for common alert types
+     */
+    static createReadinessAlert(): AlertBuilder;
+    static createOperationsAlert(): AlertBuilder;
+    static createSecurityAlert(): AlertBuilder;
+    static createEnergyAlert(): AlertBuilder;
+    /**
+     * Creates a device-specific alert builder
+     */
+    static createDeviceAlert(deviceId: string, propertyId: string): AlertBuilder;
+    /**
+     * Creates a hub-specific alert builder
+     */
+    static createHubAlert(hubId: string, propertyId: string): AlertBuilder;
+}

package/dist/device/local/entities/AlertBuilder.example.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Example usage of AlertBuilder
+ * This file demonstrates various ways to use the AlertBuilder pattern
+ */
+export declare function createBasicAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createDeviceAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createSecurityAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createEnergyAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createHubAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createSnoozedAlert(): import("../../../types/alert.types").CreateAlertData;
+export declare function createMultipleAlerts(): import("../../../types/alert.types").CreateAlertData[];

package/dist/device/local/entities/IssueBuilder.d.ts

@@ -0,0 +1,109 @@
+import { CreateIssueData, IssuesCategory, IssuePriority, EntityType } from "../../../types/issue.types";
+/**
+ * IssueBuilder - A builder pattern implementation for constructing CreateIssueData objects
+ *
+ * This builder provides a fluent interface for creating issue data with proper validation
+ * and default values. It follows the Builder pattern which is a standard design pattern
+ * in TypeScript for constructing complex objects.
+ *
+ * Usage example:
+ * const issueData = new IssueBuilder()
+ *   .setCategory(IssuesCategory.OPERATIONS)
+ *   .setPropertyId("prop123")
+ *   .setTitle("Device Maintenance Required")
+ *   .setDescription("Device requires scheduled maintenance")
+ *   .setEntityId("device456")
+ *   .setEntityType(EntityType.DEVICE)
+ *   .setPriority(IssuePriority.HIGH)
+ *   .setAssignedTo("tech789")
+ *   .setCreatedBy("user123")
+ *   .setDueDate(new Date("2024-01-15"))
+ *   .build();
+ */
+export declare class IssueBuilder {
+    private data;
+    /**
+     * Sets the issue category
+     */
+    setCategory(category: IssuesCategory): IssueBuilder;
+    /**
+     * Sets the property ID
+     */
+    setPropertyId(propertyId: string): IssueBuilder;
+    /**
+     * Sets the issue title
+     */
+    setTitle(title: string): IssueBuilder;
+    /**
+     * Sets the issue description
+     */
+    setDescription(description: string): IssueBuilder;
+    /**
+     * Sets the entity ID (optional)
+     */
+    setEntityId(entityId?: string): IssueBuilder;
+    /**
+     * Sets the entity type
+     */
+    setEntityType(entityType: EntityType): IssueBuilder;
+    /**
+     * Sets the issue priority (optional, defaults to MEDIUM)
+     */
+    setPriority(priority?: IssuePriority): IssueBuilder;
+    /**
+     * Sets the user assigned to the issue (optional)
+     */
+    setAssignedTo(assignedTo?: string): IssueBuilder;
+    /**
+     * Sets the user who created the issue (required)
+     */
+    setCreatedBy(createdBy: string): IssueBuilder;
+    /**
+     * Sets the due date (optional)
+     */
+    setDueDate(dueDate?: Date): IssueBuilder;
+    /**
+     * Validates that all required fields are present
+     */
+    private validate;
+    /**
+     * Builds and returns the CreateIssueData object
+     * @throws Error if required fields are missing
+     */
+    build(): CreateIssueData;
+    /**
+     * Resets the builder to its initial state
+     */
+    reset(): IssueBuilder;
+    /**
+     * Creates a new builder instance with predefined values for common issue types
+     */
+    static createReadinessIssue(): IssueBuilder;
+    static createOperationsIssue(): IssueBuilder;
+    static createSecurityIssue(): IssueBuilder;
+    static createEnergyIssue(): IssueBuilder;
+    /**
+     * Creates a device-specific issue builder
+     */
+    static createDeviceIssue(deviceId: string, propertyId: string): IssueBuilder;
+    /**
+     * Creates a hub-specific issue builder
+     */
+    static createHubIssue(hubId: string, propertyId: string): IssueBuilder;
+    /**
+     * Creates a user-specific issue builder
+     */
+    static createUserIssue(userId: string, propertyId: string): IssueBuilder;
+    /**
+     * Creates a property-specific issue builder
+     */
+    static createPropertyIssue(propertyId: string): IssueBuilder;
+    /**
+     * Creates a maintenance issue builder
+     */
+    static createMaintenanceIssue(propertyId: string, entityId?: string, entityType?: EntityType): IssueBuilder;
+    /**
+     * Creates an urgent issue builder
+     */
+    static createUrgentIssue(propertyId: string, entityId?: string, entityType?: EntityType): IssueBuilder;
+}

package/dist/device/local/entities/IssueBuilder.example.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Example usage of IssueBuilder
+ * This file demonstrates various ways to use the IssueBuilder pattern
+ */
+export declare function createBasicIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createDeviceIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createSecurityIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createEnergyIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createHubIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createUserIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createPropertyIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createMaintenanceIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createUrgentIssue(): import("../../../types/issue.types").CreateIssueData;
+export declare function createMultipleIssues(): import("../../../types/issue.types").CreateIssueData[];
+export declare function createIssueWithDueDate(): import("../../../types/issue.types").CreateIssueData;
+export declare function createUnassignedIssue(): import("../../../types/issue.types").CreateIssueData;