isy-nodejs 1.0.1-alpha.6 → 1.0.1-alpha.9

package/src/ISY.ts

@@ -10,7 +10,6 @@ import { EventEmitter } from 'events';
 import winston, { format, Logger, loggers, type LeveledLogMethod } from 'winston';
 import { Category } from './Definitions/Global/Categories.js';
 import { Family } from './Definitions/Global/Families.js';
-import type { NodeInfo } from './Model/NodeInfo.js';
 import { DeviceFactory } from './Devices/DeviceFactory.js';
 import { ELKAlarmPanelDevice } from './Devices/Elk/ElkAlarmPanelDevice.js';
 import { ElkAlarmSensorDevice } from './Devices/Elk/ElkAlarmSensorDevice.js';
@@ -31,13 +30,14 @@ import { InsteonOnOffOutletDevice } from './Devices/Insteon/InsteonOnOffOutletDe
 import { InsteonRelayDevice } from './Devices/Insteon/InsteonRelayDevice.js';
 import { InsteonSmokeSensorDevice } from './Devices/Insteon/InsteonSmokeSensorDevice.js';
 import { InsteonThermostatDevice } from './Devices/Insteon/InsteonThermostatDevice.js';
+import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
 import { EventType } from './Events/EventType.js';
 import { NodeType, Props, States, VariableType } from './ISYConstants.js';
-import { ISYNode } from './ISYNode.js';
-import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
 import { type ISYDevice } from './ISYDevice.js';
+import { ISYNode } from './ISYNode.js';
 import { ISYScene } from './ISYScene.js';
 import { ISYVariable } from './ISYVariable.js';
+import type { NodeInfo } from './Model/NodeInfo.js';
 
 import * as Utils from './Utils.js';
 
@@ -118,6 +118,21 @@ const parser = new Parser(defaultParserOptions);
 
 export let Controls = {};
 
+interface ISYConfig {
+	// #region Properties (8)
+
+	displayNameFormat?: string;
+	elkEnabled?: boolean;
+	enableWebSocket?: boolean;
+	host: string;
+	password: string;
+	port: number;
+	protocol: 'http' | 'https';
+	username: string;
+
+	// #endregion Properties (8)
+}
+
 export class ISY extends EventEmitter implements Disposable {
 	// #region Properties (30)
 
@@ -158,20 +173,7 @@ export class ISY extends EventEmitter implements Disposable {
 
 	// #region Constructors (1)
 
-	constructor(
-		config: {
-			host: string;
-			port: number;
-			protocol: 'http' | 'https';
-			username: string;
-			password: string;
-			enableWebSocket?: boolean;
-			displayNameFormat?: string;
-			elkEnabled?: boolean;
-		},
-		logger: Logger = new Logger(),
-		storagePath?: string
-	) {
+	constructor(config: ISYConfig, logger: Logger = new Logger(), storagePath?: string) {
 		super();
 		this.enableWebSocket = config.enableWebSocket ?? true;
 		this.storagePath = storagePath ?? './';
@@ -218,7 +220,15 @@ export class ISY extends EventEmitter implements Disposable {
 
 	// #endregion Public Getters And Setters (2)
 
-	// #region Public Methods (22)
+	// #region Public Methods (24)
+
+	[Symbol.dispose](): void {
+		try {
+			this.webSocket?.close();
+		} catch (e) {
+			this.logger.error(`Error closing websocket: ${e.message}`);
+		}
+	}
 
 	public override emit(event: 'InitializeCompleted' | 'NodeAdded' | 'NodeRemoved' | 'NodeChanged', node?: ISYNode<any, any, any, any>): boolean {
 		return super.emit(event, node);
@@ -239,6 +249,10 @@ export class ISY extends EventEmitter implements Disposable {
 		return s as T;
 	}
 
+	public getElkAlarmPanel() {
+		return this.elkAlarmPanel;
+	}
+
 	public getNode<T extends ISYNode<any, any, any, any> = ISYNode<any, any, any, any>>(address: string, parentsOnly = false): T {
 		let s = this.nodeMap.get(address);
 		if (!parentsOnly) {
@@ -254,10 +268,6 @@ export class ISY extends EventEmitter implements Disposable {
 		return s as T;
 	}
 
-	public getElkAlarmPanel() {
-		return this.elkAlarmPanel;
-	}
-
 	public getScene(address: string) {
 		return this.sceneList.get(address);
 	}
@@ -569,6 +579,7 @@ export class ISY extends EventEmitter implements Disposable {
 			trailingSlash: boolean;
 			requestLogLevel?: any;
 			responseLogLevel?: any;
+			errorLogLevel?: any;
 		} = { trailingSlash: true }
 	): Promise<any> {
 		const requestLogLevel = options.requestLogLevel ?? 'debug';
@@ -585,19 +596,22 @@ export class ISY extends EventEmitter implements Disposable {
 					if (options.parserOptions) curParser = new Parser({ ...defaultParserOptions, ...options.parserOptions });
 					var altParser = new XMLParser(defaultXMLParserOptions);
 					var s = altParser.parse(response.data);
-					this.logger.log(requestLogLevel ?? 'debug',`Response: ${JSON.stringify(s)}`);
+					this.logger.log(requestLogLevel ?? 'debug', `Response: ${JSON.stringify(s)}`);
 					return s;
 				} else if (response.headers['content-type'].toString().includes('json')) {
 					this.logger.log(responseLogLevel ?? 'debug', `Response: ${JSON.stringify(response.data)}`);
 					return JSON.parse(response.data);
 				} else {
-					this.logger.log(responseLogLevel ?? 'debug',`Response Header: ${JSON.stringify(response.headers)} Response: ${JSON.stringify(response.data)}`);
+					this.logger.log(responseLogLevel ?? 'debug', `Response Header: ${JSON.stringify(response.headers)} Response: ${JSON.stringify(response.data)}`);
 					return response.data;
 				}
 			}
 		} catch (error) {
-			this.logger.error(`Error sending request to ISY: ${error?.message}`);
-			throw new Error(`Error sending request to ISY: ${JSON.stringify(error)}`);
+			if (options.errorLogLevel) {
+				this.logger.log(options.errorLogLevel, `Error sending request to ISY: ${error?.message}`);
+			} else {
+				this.logger.error(`Error sending request to ISY: ${error?.message}`);
+			}
 		}
 	}
 
@@ -608,11 +622,15 @@ export class ISY extends EventEmitter implements Disposable {
 		return this.sendRequest(uriToUse);
 	}
 
-	public variableChangedHandler(variable: { id: string; type: string }) {
+	#variableChangedHandler(variable: { id: string; type: string }) {
 		this.logger.info(`Variable: ${variable.id} (${variable.type}) changed`);
 	}
 
-	// #endregion Public Methods (22)
+	public close() {
+		if (this.webSocket) this.webSocket.close();
+	}
+
+	// #endregion Public Methods (24)
 
 	// #region Private Methods (11)
 
@@ -649,12 +667,13 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	#guardian() {
+	async #guardian() {
 		const timeNow = new Date();
 
 		if (Number(timeNow) - Number(this.lastActivity) > 60000) {
 			this.logger.info('Guardian: Detected no activity in more then 60 seconds. Reinitializing web sockets');
-			this.initializeWebSocket();
+			await this.refreshStatuses();
+			await this.initializeWebSocket();
 		}
 	}
 
@@ -802,13 +821,9 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	[Symbol.dispose](): void {
-		try {
-			this.webSocket.close();
-		} catch (e) {
-			this.logger.error(`Error closing websocket: ${e.message}`);
-		}
-	}
-
 	// #endregion Private Methods (11)
 }
+
+export namespace ISY {
+	export interface Config extends ISYConfig {}
+}

package/src/ISYNode.ts

@@ -6,7 +6,7 @@ import { UnitOfMeasure } from './Definitions/Global/UOM.js';
 import { ISY, NodeType, type ISYScene } from './ISY.js';
 
 import { CliConfigSetLevels } from 'winston/lib/winston/config/index.js';
-import { Converters } from './Converters.js';
+import { Converter } from './Converters.js';
 import type { Command } from './Definitions/Global/Commands.js';
 import { Event } from './Definitions/Global/Events.js';
 import type { Constructor } from './Devices/Constructor.js';
@@ -168,7 +168,7 @@ export class ISYNode<
 		if (from === to) return value;
 		else {
 			try {
-				return Converters.Standard[from][to].from(value);
+				return Converter.Standard[from][to].from(value);
 			} catch {
 				this.isy.logger.error(`Conversion from ${UnitOfMeasure[from]} to ${UnitOfMeasure[to]} not supported.`);
 			} finally {
@@ -191,7 +191,7 @@ export class ISYNode<
 		}
 	}
 
-	public emit(event: 'PropertyChanged' | 'ControlTriggered', propertyName?: string, newValue?: any, oldValue?: any, formattedValue?: string, controlName?: string) {
+	public emit(event: 'propertyChanged' | 'controlTriggered', propertyName?: string, newValue?: any, oldValue?: any, formattedValue?: string, controlName?: string) {
 		//if ('PropertyChanged') return super.emit(event, propertyName, newValue, oldValue, formattedValue);
 		//else if ('ControlTriggered') return super.emit(event, controlName);
 	}
@@ -232,7 +232,7 @@ export class ISYNode<
 
 	public handleControlTrigger(controlName: keyof E & keyof C): boolean {
 		//this.lastChanged = new Date();
-		this.events.emit('ControlTriggered', controlName);
+		this.events.emit('controlTriggered', controlName);
 		return true;
 	}
 
@@ -255,20 +255,23 @@ export class ISYNode<
 			const e = event.control;
 			const dispName = this.commands[e]?.name;
 			if (dispName !== undefined && dispName !== null) {
-				this.logger(`Command ${dispName} (${e}) triggered.`);
+				this.logger(`Command ${dispName} (${e}) event sent.`);
 			} else {
-				this.logger(`Command ${e} triggered.`);
+				this.logger(`Command ${e} event sent.`);
 			}
 			this.handleControlTrigger(e);
 			return true;
 		}
 	}
 
-	public handlePropertyChange(propertyName: StringKeys<D>, value: any, uom: UnitOfMeasure, formattedValue: string, prec?: number): boolean {
+	public handlePropertyChange(propertyName: StringKeys<D>, value: any, uom: UnitOfMeasure, prec?: number, formattedValue?: string): boolean {
 		this.lastChanged = new Date();
-		const oldValue = this.drivers[propertyName].value;
-		if (this.drivers[propertyName].patch(value, formattedValue, uom, prec)) {
-			this.emit('PropertyChanged', propertyName, value, oldValue, formattedValue);
+		let driver = this.drivers[propertyName];
+		this.logger(`Driver ${propertyName} (${driver?.label} value update ${value} (${formattedValue}) uom: ${UnitOfMeasure[uom]} event received.`);
+		const oldValue = driver?.value;
+		if (driver?.patch(value, formattedValue, uom, prec)) {
+			this.logger(`Driver ${driver.label} updated from ${oldValue} to ${value} (${formattedValue})`);
+			this.emit('propertyChanged', propertyName, value, oldValue, formattedValue);
 			this.scenes?.forEach((element) => {
 				this.logger(`Recalulating ${element.deviceFriendlyName}`);
 				element.recalculateState();

package/src/ISYScene.ts

@@ -110,10 +110,10 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 	}
 	public markAsChanged() {
 		this.lastChanged = new Date();
-		this.emit('PropertyChanged', 'isOn', this.isOn, this.isOn, this.isOn ? 'on' : 'off');
+		this.emit('propertyChanged', 'isOn', this.isOn, this.isOn, this.isOn ? 'on' : 'off');
 
 		if (this.isDimmable) {
-			this.emit('PropertyChanged', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel, this.brightnessLevel + '%');
+			this.emit('propertyChanged', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel, this.brightnessLevel + '%');
 
 		}
 	}

package/src/Matter/Behaviors/ISYBridgedDeviceBehavior.ts

@@ -11,11 +11,11 @@ import internal from 'stream';
 import type { Driver } from '../../Definitions/Global/Drivers.js';
 import { ISY, type Family, type ISYNode } from '../../ISY.js';
 import type { ISYDevice } from '../../ISYDevice.js';
-import { DeviceToClusterMap, MappingRegistry, type ClusterMapping } from '../../Model/ClusterMap.js';
+import { DeviceToClusterMap, MappingRegistry, type ClusterMapping, type BehaviorMapping } from '../../Model/ClusterMap.js';
 
 
 type ClusterForBehavior<B extends ClusterBehavior> = B extends ClusterBehavior.Type<infer C> ? C : never;
-export class ISYBridgedDeviceBehavior extends Behavior {
+export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D extends ISYNode.DriverSignatures = ISYNode.DriverSignatures> extends Behavior {
 	static override readonly id = 'isyNode';
 
 	static override readonly early = true;
@@ -23,16 +23,24 @@ export class ISYBridgedDeviceBehavior extends Behavior {
 	declare internal: ISYBridgedDeviceBehavior.Internal;
 	declare state: ISYBridgedDeviceBehavior.State;
 
-	declare events: ISYBridgedDeviceBehavior.Events;
+	declare events: ISYBridgedDeviceBehavior.Events & ISYBridgedDeviceBehavior.EventsFor<N["drivers"]>;
 
 	override async initialize(_options?: {}) {
 		await super.initialize(_options);
 		var address = this.state.address;
-		this.internal.device = ISY.instance.nodeMap.get(this.state.address);
-		this.internal.map = MappingRegistry.getMapping(this.internal.device as unknown as ISYDevice<Family, any, any, any>);
+		const d = ISY.instance.nodeMap.get(this.state.address);
+		this.internal.device = d;
+		this.internal.map = MappingRegistry.getMapping(this.internal.device as unknown as ISYNode<Family, any, any, any>);
 		ISY.instance.logger.debug(`Initializing ${this.constructor.name} for ${this.internal.device.constructor.name} ${this.internal.device.name} with address ${address}`);
-		if (this.internal.device) {
-			this.internal.device.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+		if (d) {
+			d.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+			for(const f in d.drivers)
+			{
+				let evt = `${d.drivers[f].name}Changed`;
+				this.events[evt] = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+				//@ts-ignore
+				d.events.on(evt, (driver: string, newValue: any, oldValue: any, formattedValue: string) => this.events.emit(evt, { driver, newValue, oldValue, formattedValue } as unknown as any));
+			}
 		}
 	}
 
@@ -44,8 +52,8 @@ export class ISYBridgedDeviceBehavior extends Behavior {
 		return this.internal.map;
 	}
 
-	mapForBehavior<B extends { cluster: unknown }>(behavior: B): ClusterMapping<B['cluster'], typeof this.internal.device> {
-		return this.map[behavior.cluster['name']];
+	mapForBehavior<B extends ClusterBehavior>(behavior: B): BehaviorMapping<B, typeof this.internal.device> {
+		return this.map.mapping[behavior.cluster['name']];
 	}
 
 	handlePropertyChange(driver: string, newValue: any, oldValue: any, formattedValue: string) {
@@ -64,8 +72,18 @@ export namespace ISYBridgedDeviceBehavior {
 		map?: DeviceToClusterMap<typeof this.device, any>;
 	}
 
-	export class Events extends EventEmitter {
+	export type EventsFor<D extends {[x: string]: Driver<any,any,any>}> = {
+		[s in keyof D as `${D[s]["name"]}Changed`] : Observable<[{ driver: s; newValue: any; oldValue: any; formattedValue: string }]>;
+	}
+
+
+
+
+	export class Events extends EventEmitter{
 		propertyChanged = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+
+
+
 	}
 
 	export class State {

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -1,38 +1,50 @@
-import type { ClusterBehavior, ClusterInterface } from '@project-chip/matter.js/behavior/cluster';
-
-import type { DriversOf, ISYNode } from '../../ISYNode.js';
-
 import type { Behavior } from '@project-chip/matter.js/behavior';
+import type { ClusterBehavior, ClusterInterface } from '@project-chip/matter.js/behavior/cluster';
 import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
 import type { LevelControlBehavior } from '@project-chip/matter.js/behaviors/level-control';
 import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
 import type { Cluster, ClusterServerHandlers, ClusterType as CT } from '@project-chip/matter.js/cluster';
 import '@project-chip/matter.js/device';
 import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
-import { DriverType } from '../../Definitions/Global/Drivers.js';
+import { Converter } from '../../Converters.js';
+import { Driver, DriverType } from '../../Definitions/Global/Drivers.js';
 import type { Constructor } from '../../Devices/Constructor.js';
 import type { RelaxTypes } from '../../Devices/MapsTo.js';
 import { ISY, type ISYDevice } from '../../ISY.js';
-import { MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
-
+import type { DriversOf, ISYNode } from '../../ISYNode.js';
+import { BehaviorMapping, MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
 import { ISYBridgedDeviceBehavior } from './ISYBridgedDeviceBehavior.js';
 
-type NotUnknown<T extends ClusterBehavior> = T extends { cluster: { name: 'Unknown' } } ? never : T;
+// #region Type aliases (6)
 
+export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
 export type ConstructedType<B extends Constructor<any>> = B extends Constructor<infer C> ? C : never;
+// <reference path="MatterDevice.js" />
+// @ts-ignore
+export type DeviceBehavior<P extends ISYNode, T extends { cluster? }> = {
+	device: P;
 
-export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
+	bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 
-type t = ClusterForBehavior<LevelControlBehavior>;
+	//ts-ignore
+	map: BehaviorMapping<T, P>;
 
+	handlePropertyChange(chg: PropertyChange<P>): void;
+};
+type NotUnknown<T extends ClusterBehavior> = T extends { cluster: { name: 'Unknown' } } ? never : T;
 export type PropertyChange<P extends ISYNode<any, any, any, any>> = {
 	driver: keyof DriversOf<P>;
 	newValue: any;
 	oldValue: any;
 	formattedValue: string;
 };
+type t = ClusterForBehavior<LevelControlBehavior>;
+
+// #endregion Type aliases (6)
 
-export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster: unknown }, P extends ISYNode<any, any, any, any>>(
+// #region Functions (1)
+
+export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster }, P extends ISYNode<any, any, any, any>>(
 	base: T,
 	p: Constructor<P>
 ): typeof base & { new (...args: any[]): DeviceBehavior<P, T> } {
@@ -41,30 +53,44 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 
 		handlers: { [x in keyof DriversOf<P>]: (newValue, oldValue, formattedValue) => void } = {} as any;
 
+		bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 		///public map: ClusterMapping<ToClusterTypeByName<ClusterForBehavior<ConstructedType<typeof base>>["name"]>,ISYDeviceNode<any, any, any>>;
 
-		map: ClusterMapping<T['cluster'], P>;
+		map: BehaviorMapping<T, P>;
 
 		override async initialize(_options?: {}) {
 			await super.initialize(_options);
-			var behavior = await this.agent.load(ISYBridgedDeviceBehavior);
+			var behavior = (await this.agent.load(ISYBridgedDeviceBehavior)) as ISYBridgedDeviceBehavior<P>;
+			this.bridgedDeviceBehavior = behavior;
 			//var behavior = this.agent.get(ISYBridgedDeviceBehavior);
 			this._device = behavior.device as P;
+			//@ts-ignore
 			this.map = behavior.mapForBehavior<T>(this as unknown as T);
 			for (const key2 in this.map.attributes) {
-				if (typeof this.map.attributes[key2] === 'string') {
-					this.handlers[this.map.attributes[key2]] = (newValue, oldValue, formattedValue) => {
+				let val = this.map.attributes[key2];
+				let driverObj = null;
+				if (typeof val === 'string' || typeof val === 'symbol' || typeof val === 'number') {
+					driverObj = this._device.drivers[val];
+					this.handlers[val] = (newValue, oldValue, formattedValue) => {
 						this.state[key2 as string] = newValue;
 					};
-				} else if (this.map.attributes[key2].driver) {
-					let { driver, converter } = this.map.attributes[key2];
+				} else if (val.driver as DriversOf<P>) {
+					driverObj = this._device.drivers[val.driver as string];
+
+					let { driver, converter } = val;
+					const convFunc = Converter.get(converter)?.from;
 					this.handlers[driver] = (newValue, oldValue, formattedValue) => {
-						this.state[key2 as string] = converter(newValue);
+						if (convFunc) this.state[key2 as string] = convFunc(newValue);
+						else this.state[key2 as string] = newValue;
 					};
 				}
+				if (driverObj) {
+					let evt = `${driverObj.name}Changed`;
+					this.reactTo(behavior.events[evt], this.handlePropertyChange.bind(this), { lock: false });
+				}
 			}
 
-			this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
+			//this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
 
 			//this._device.on("PropertyChanged", this.handlePropertyChange.bind(this));
 		}
@@ -95,13 +121,5 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 		}
 	};
 }
-// <reference path="MatterDevice.js" />
-// @ts-ignore
-
-export type DeviceBehavior<P extends ISYNode, T extends { cluster }> = {
-	device: P;
 
-	map: ClusterMapping<T['cluster'], P>;
-
-	handlePropertyChange(chg: PropertyChange<P>): void;
-};
+// #endregion Functions (1)

package/src/Matter/Behaviors/ISYOnOffBehavior.ts

@@ -1,80 +1,69 @@
-import { InsteonRelayDevice } from "../../Devices/Insteon/InsteonRelayDevice.js"
-import { OnOffLightRequirements } from "@project-chip/matter.js/devices/OnOffLightDevice";
-import { ISYClusterBehavior, ClusterForBehavior, type PropertyChange } from "./ISYClusterBehavior.js";
+import type { LevelControlInterface, LevelControlServer } from '@project-chip/matter.js/behaviors/level-control';
+import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
+import type { MutableCluster, OnOffCluster } from '@project-chip/matter.js/cluster';
+import { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
+import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
 import { OnOffLightSwitchDevice } from '@project-chip/matter.js/devices/OnOffLightSwitchDevice';
 import type { MaybePromise } from '@project-chip/matter.js/util';
-import { MappingRegistry } from '../../Model/ClusterMap.js';
-import type { MutableCluster, OnOffCluster } from '@project-chip/matter.js/cluster';
-import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
-import type { LevelControlServer, LevelControlInterface } from '@project-chip/matter.js/behaviors/level-control';
 import { DriverType } from '../../Definitions/Global/Drivers.js';
-import { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
 import { InsteonDimmableDevice } from '../../Devices/Insteon/InsteonDimmableDevice.js';
+import { InsteonRelayDevice } from '../../Devices/Insteon/InsteonRelayDevice.js';
+import { MappingRegistry } from '../../Model/ClusterMap.js';
+import { ClusterForBehavior, ISYClusterBehavior, type PropertyChange } from './ISYClusterBehavior.js';
 
-import {Converters} from '../../Converters.js';
-
-
-
-
-
-export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice)
-{
-
-    override async initialize(_options?: {}) {
-        await super.initialize(_options);
-        //this.state.onOff = await this.device.state;
-
-
+import { Converter } from '../../Converters.js';
 
-    }
+export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice) {
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		//this.state.onOff = await this.device.state;
+	}
 
+	override on = async () => {
+		await super.on();
+		await this.device.on();
 
-  override on = async () => {
-    await super.on();
+		//this.device.commands.DON = true;
+	};
 
+	override async off() {
+		await super.off();
+		await this.device.off();
 
-     //this.device.commands.DON = true;
-  }
 
-  override async off() {
-    //await super.off();
-    // this.device.drivers = false;
-  }
 
-  override toggle =  async () => {
-    //this.device.state = !(await this.device.state);
-  }
+		// this.device.drivers = false;
+	}
 
-  override async handlePropertyChange({driver, newValue, oldValue, formattedValue}: PropertyChange<InsteonRelayDevice>) {
-    if (driver === "ST") {
-      this.state.onOff = newValue;
+	override toggle = async () => {
 
-    }
+		//this.device.state = !(await this.device.state);
+	};
 
-    return super.handlePropertyChange({driver, newValue, oldValue, formattedValue});
-  }
+	override async handlePropertyChange({ driver, newValue, oldValue, formattedValue }: PropertyChange<InsteonRelayDevice>) {
+		/*if (driver === 'ST') {
+			this.state.onOff = newValue;
+		}*/
 
 
+		return super.handlePropertyChange({ driver, newValue, oldValue, formattedValue });
+	}
 }
 
-
 export class ISYDimmableBehavior extends ISYClusterBehavior(DimmableLightRequirements.LevelControlServer, InsteonDimmableDevice) {
-  override async initialize(_options?: {}) {
-    await super.initialize(_options);
-    this.state.currentLevel = this.device.drivers.ST.value;
-    //this.state.onLevel = this.device.drivers.OL;
-
-  }
-
-  override setLevel(level: number): MaybePromise<void> {
-    level = Converters.Matter.LevelFrom0To255.LightingLevel.to(level);
-    if(level > 0)
-    {
-        return this.device.sendCommand('DON',level);
-    }
-    else
-    {
-        return this.device.sendCommand('DOF');
-    }
-  }
-}
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		this.state.currentLevel = this.device.drivers.ST.value;
+
+		//this.state.onLevel = this.device.drivers.OL;
+	}
+
+	override setLevel(level: number): MaybePromise<void> {
+		level = Converter.Matter.LevelFrom0To255.LightingLevel.from(level);
+		if (level > 0) {
+			return this.device.sendCommand('DON', level);
+		} else {
+			return this.device.sendCommand('DOF');
+		}
+	}
+}