isy-nodejs 1.0.6-alpha.0 → 1.0.6-alpha.1

package/src/Devices/MapsTo.ts

@@ -1,28 +1,3 @@
 import { Behavior } from '@project-chip/matter.js/behavior';
 
 import type { Cluster, ClusterType, MutableCluster } from '@project-chip/matter.js/cluster';
-
-
-export type RelaxTypes<V> = V extends number
-        ? number
-        : V extends bigint
-          ? bigint
-          : V extends object
-            ? V extends (...args: any[]) => any
-                ? V
-                : {
-                      [K in keyof V]: RelaxTypes<V[K]>;
-                  }
-            : V;
-
-/*
-
-export interface MapsTo<T extends Behavior.Type, T1 extends Behavior.Type = T, T2 extends Behavior.Type = T, T3 extends Behavior.Type = T> {
-	 initialize(endpoint: EndpointFor<T, T1, T2, T3>): void | Promise<void>;
-
-}
-
-export interface MapsToCluster<T extends ClusterType.Of<ClusterType.Options<{}>>, T1 extends ClusterType = T, T2 extends ClusterType = T, T3 extends ClusterType = T> {
-	initialize(endpoint: EndpointForCluster<T,T1, T2, T3>): void;
-
-}*/

package/src/Devices/NCD/Generated/Relay.ts

@@ -29,19 +29,22 @@ export class RelayNode extends Base<Drivers, Commands> implements Relay.Interfac
 	declare readonly nodeDefId: "NCDRelay";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Responding", name: "responding" });
 	}
 	async on() { return this.sendCommand("DON"); }
 	async off() { return this.sendCommand("DOF"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async adr(value: (0 | 1)) { return this.sendCommand("ADRPST", value); }
-	public get status(): (0 | 100) {
-		return this.drivers.ST?.value;
-	}
-	public get responding(): NCD.Error {
-		return this.drivers.ERR?.value;
-	}
+	async adr(value: ) { return this.sendCommand("ADRPST", value); }
+	public get status(): {
+        
+return this.drivers.ST?.value;
+    }
+    public 
+get responding(): 
+{
+	return this.drivers.ERR?.value;
+}
 }
 
 NodeFactory.register(RelayNode);
@@ -73,21 +76,21 @@ export namespace Relay {
 			label: "Query";
 			name: "query";
 		};
-		ADRPST: ((value: (0 | 1)) => Promise<boolean>) & {
+		ADRPST: ((value: ) => Promise<boolean>) & {
 			label: "ADR";
 			name: "adr";
 		};
 	};
 	export type Drivers = {
 		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: (0 | 100);
+			uom: ;
+			value: ;
 			label: "Status";
 			name: "status";
 		};
 		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: NCD.Error;
+			uom: ;
+			value: ;
 			label: "Responding";
 			name: "responding";
 		};

package/src/Devices/NodeFactory.ts

@@ -86,7 +86,7 @@ export namespace NodeFactory {
 	export async function get<F extends keyof typeof Family>(node: NodeInfo<typeof Family[F]>, isy: ISY = ISY.instance): Promise<typeof ISYNode<typeof Family[F], any, any, any>> {
 		if (!isDynamic(node))
 		{
-			return Promise.resolve(getForNodeDefId(Family[node.family] as F, node.nodeDefId));
+			return Promise.resolve(getForNodeDefId(Family[node.family ?? Family.Insteon]  as F, node.nodeDefId));
 		}
 
 		else {

package/src/Devices/ZWave/ZWaveBaseDevice.ts

@@ -7,9 +7,10 @@ import { ISYNode } from '../../ISYNode.js';
 import 'winston';
 import type { Driver } from '../../Definitions/Global/Drivers.js';
 import type { Merge } from '@matter/general';
+import { DynamicNode } from '../DynamicNode.js';
 
 // import { InsteonNLS } from './insteonfam'
-export class ZWaveBaseDevice<D extends ISYNode.DriverSignatures = {}, C extends ISYNode.CommandSignatures = {}> extends ISYDeviceNode<Family.ZWave,Merge<D,Driver.Signatures<'ST'>>,C> {
+export class ZWaveBaseDevice<D extends ISYNode.DriverSignatures, C extends ISYNode.CommandSignatures, E extends ISYNode.EventSignatures = {}> extends DynamicNode<Family.ZWave,Merge<D,Driver.Signatures<'ST'>>,C,E > {
 
 	public async getNodeDef()
 	{

package/src/Devices/ZWave/ZWaveDimmerSwitchDevice.ts

@@ -1,10 +1,11 @@
 
 
 
+import { DimmerSwitch } from './Generated/DimmerSwitch.js';
 import { ZWaveBaseDevice } from './ZWaveBaseDevice.js';
 import 'winston';
 
-export class ZWaveDimmerSwitchDevice extends ZWaveBaseDevice {
+export class ZWaveDimmerSwitchDevice extends DimmerSwitch.Node {
 	constructor (isy: any, deviceNode: any) {
 		super(isy, deviceNode);
 	}

package/src/Devices/ZWave/ZWaveLockDevice.ts

@@ -1,11 +1,12 @@
+import { ZWave, type Driver } from '../../Definitions/index.js';
 import { ISY } from '../../ISY.js';
-import { Commands, States } from '../../ISYConstants.js';
+
 
 import { ZWaveBaseDevice } from './ZWaveBaseDevice.js';
 import 'winston';
 
 
-export class ZwaveLockDevice extends ZWaveBaseDevice {
+export class ZwaveLockDevice extends ZWaveBaseDevice<Driver.Signatures<'ST'>,any,any> {
 	constructor (isy: ISY, deviceNode: any
 	) {
 		super(isy, deviceNode);
@@ -27,18 +28,18 @@ export class ZwaveLockDevice extends ZWaveBaseDevice {
 
 	public async sendNonSecureLockCommand(lockState: any) {
 		if (lockState) {
-			return this.isy.sendNodeCommand(this, Commands.Lock.Lock);
+			return this.isy.sendNodeCommand(this, 'DON');
 		}
 		else {
-			return this.isy.sendNodeCommand(this, Commands.Lock.Unlock);
+			return this.isy.sendNodeCommand(this, 'DOF');
 		}
 	}
 	public async sendSecureLockCommand(lockState: any) {
 		if (lockState) {
-			return this.isy.sendNodeCommand(this, Commands.On, States.SecureLock.Secured);
+			return this.isy.sendNodeCommand(this, 'DON', ZWave.OnOff);
 		}
 		else {
-			return this.isy.sendNodeCommand(this, Commands.On, States.SecureLock.NotSecured);
+			return this.isy.sendNodeCommand(this, 'DON', 0);
 		}
 	}
 }

package/src/Devices/ZigBeeLegacy/Generated/Relay.ts

@@ -29,22 +29,19 @@ export class RelayNode extends Base<Drivers, Commands> implements Relay.Interfac
 	declare readonly nodeDefId: "RelayLoadControl";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on() { return this.sendCommand("DON"); }
 	async off() { return this.sendCommand("DOF"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async adr(value: ) { return this.sendCommand("ADRPST", value); }
-	public get status(): {
-        
-return this.drivers.ST?.value;
-    }
-    public 
-get responding(): 
-{
-	return this.drivers.ERR?.value;
-}
+	async adr(value: (0 | 1)) { return this.sendCommand("ADRPST", value); }
+	public get status(): (0 | 100) {
+		return this.drivers.ST?.value;
+	}
+	public get responding(): ZigBeeLegacy.Error {
+		return this.drivers.ERR?.value;
+	}
 }
 
 NodeFactory.register(RelayNode);
@@ -76,21 +73,21 @@ export namespace Relay {
 			label: "Query";
 			name: "query";
 		};
-		ADRPST: ((value: ) => Promise<boolean>) & {
+		ADRPST: ((value: (0 | 1)) => Promise<boolean>) & {
 			label: "ADR";
 			name: "adr";
 		};
 	};
 	export type Drivers = {
 		ST: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.Percent;
+			value: (0 | 100);
 			label: "Status";
 			name: "status";
 		};
 		ERR: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.Index;
+			value: ZigBeeLegacy.Error;
 			label: "Responding";
 			name: "responding";
 		};

package/src/Devices/ZigBeeLegacy/Generated/Thermostat.ts

@@ -34,69 +34,52 @@ export class ThermostatNode extends Base<Drivers, Commands> implements Thermosta
 	declare readonly nodeDefId: "Thermostat";
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Temperature", name: "temperature" });
-		this.drivers.CLISPH = Driver.create("CLISPH", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Heat Setpoint", name: "heatSetpoint" });
-		this.drivers.CLISPC = Driver.create("CLISPC", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Cool Setpoint", name: "coolSetpoint" });
-		this.drivers.CLIMD = Driver.create("CLIMD", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Mode", name: "mode" });
-		this.drivers.CLIFS = Driver.create("CLIFS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Fan Mode", name: "fanMode" });
-		this.drivers.CLIHCS = Driver.create("CLIHCS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Heat/Cool State", name: "heatCoolState" });
-		this.drivers.CLIFRS = Driver.create("CLIFRS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Fan State", name: "fanState" });
-		this.drivers.CLISMD = Driver.create("CLISMD", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Schedule Mode", name: "scheduleMode" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Unknown, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Degree, label: "Temperature", name: "temperature" });
+		this.drivers.CLISPH = Driver.create("CLISPH", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Degree, label: "Heat Setpoint", name: "heatSetpoint" });
+		this.drivers.CLISPC = Driver.create("CLISPC", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Degree, label: "Cool Setpoint", name: "coolSetpoint" });
+		this.drivers.CLIMD = Driver.create("CLIMD", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatMode, label: "Mode", name: "mode" });
+		this.drivers.CLIFS = Driver.create("CLIFS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatFanMode, label: "Fan Mode", name: "fanMode" });
+		this.drivers.CLIHCS = Driver.create("CLIHCS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatHeatCoolState, label: "Heat/Cool State", name: "heatCoolState" });
+		this.drivers.CLIFRS = Driver.create("CLIFRS", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.ThermostatFanRunState, label: "Fan State", name: "fanState" });
+		this.drivers.CLISMD = Driver.create("CLISMD", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Schedule Mode", name: "scheduleMode" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async updateHeatSetpoint(value: ) { return this.sendCommand("CLISPH", value); }
-	async updateCoolSetpoint(value: ) { return this.sendCommand("CLISPC", value); }
-	async updateMode(value: ) { return this.sendCommand("CLIMD", value); }
-	async updateFanMode(value: ) { return this.sendCommand("CLIFS", value); }
-	async updateScheduleMode(value: ) { return this.sendCommand("CLISMD", value); }
-	async heatSetpointShift(value: ) { return this.sendCommand("CLISPHD", value); }
-	async coolSetpointShift(value: ) { return this.sendCommand("CLISPCD", value); }
+	async updateHeatSetpoint(value: number) { return this.sendCommand("CLISPH", value); }
+	async updateCoolSetpoint(value: number) { return this.sendCommand("CLISPC", value); }
+	async updateMode(value: number) { return this.sendCommand("CLIMD", value); }
+	async updateFanMode(value: (0 | 1)) { return this.sendCommand("CLIFS", value); }
+	async updateScheduleMode(value: number) { return this.sendCommand("CLISMD", value); }
+	async heatSetpointShift(value: number) { return this.sendCommand("CLISPHD", value); }
+	async coolSetpointShift(value: number) { return this.sendCommand("CLISPCD", value); }
 	async query() { return this.sendCommand("QUERY"); }
-	async adr(value: ) { return this.sendCommand("ADRPST", value); }
-	public get temperature(): {
-        
-return this.drivers.ST?.value;
-    }
-    public 
-get heatSetpoint(): 
-{
-	return this.drivers.CLISPH?.value;
-}
-    public 
-get coolSetpoint(): 
-{
-	return this.drivers.CLISPC?.value;
-}
-    public 
-get mode(): 
-{
-	return this.drivers.CLIMD?.value;
-}
-    public 
-get fanMode(): 
-{
-	return this.drivers.CLIFS?.value;
-}
-    public 
-get heatCoolState(): 
-{
-	return this.drivers.CLIHCS?.value;
-}
-    public 
-get fanState(): 
-{
-	return this.drivers.CLIFRS?.value;
-}
-    public 
-get scheduleMode(): 
-{
-	return this.drivers.CLISMD?.value;
-}
-    public 
-get responding(): 
-{
-	return this.drivers.ERR?.value;
-}
+	async adr(value: (0 | 1)) { return this.sendCommand("ADRPST", value); }
+	public get temperature(): number {
+		return this.drivers.ST?.value;
+	}
+	public get heatSetpoint(): number {
+		return this.drivers.CLISPH?.value;
+	}
+	public get coolSetpoint(): number {
+		return this.drivers.CLISPC?.value;
+	}
+	public get mode(): number {
+		return this.drivers.CLIMD?.value;
+	}
+	public get fanMode(): (0 | 1) {
+		return this.drivers.CLIFS?.value;
+	}
+	public get heatCoolState(): number {
+		return this.drivers.CLIHCS?.value;
+	}
+	public get fanState(): (0 | 1) {
+		return this.drivers.CLIFRS?.value;
+	}
+	public get scheduleMode(): number {
+		return this.drivers.CLISMD?.value;
+	}
+	public get responding(): ZigBeeLegacy.Error {
+		return this.drivers.ERR?.value;
+	}
 }
 
 NodeFactory.register(ThermostatNode);
@@ -116,31 +99,31 @@ export namespace Thermostat {
 	}
 	export const Node = ThermostatNode;
 	export type Commands = {
-		CLISPH: ((value: ) => Promise<boolean>) & {
+		CLISPH: ((value: number) => Promise<boolean>) & {
 			label: "Heat Setpoint";
 			name: "updateHeatSetpoint";
 		};
-		CLISPC: ((value: ) => Promise<boolean>) & {
+		CLISPC: ((value: number) => Promise<boolean>) & {
 			label: "Cool Setpoint";
 			name: "updateCoolSetpoint";
 		};
-		CLIMD: ((value: ) => Promise<boolean>) & {
+		CLIMD: ((value: number) => Promise<boolean>) & {
 			label: "Mode";
 			name: "updateMode";
 		};
-		CLIFS: ((value: ) => Promise<boolean>) & {
+		CLIFS: ((value: (0 | 1)) => Promise<boolean>) & {
 			label: "Fan Mode";
 			name: "updateFanMode";
 		};
-		CLISMD: ((value: ) => Promise<boolean>) & {
+		CLISMD: ((value: number) => Promise<boolean>) & {
 			label: "Schedule Mode";
 			name: "updateScheduleMode";
 		};
-		CLISPHD: ((value: ) => Promise<boolean>) & {
+		CLISPHD: ((value: number) => Promise<boolean>) & {
 			label: "Heat Setpoint Shift";
 			name: "heatSetpointShift";
 		};
-		CLISPCD: ((value: ) => Promise<boolean>) & {
+		CLISPCD: ((value: number) => Promise<boolean>) & {
 			label: "Cool Setpoint Shift";
 			name: "coolSetpointShift";
 		};
@@ -148,63 +131,63 @@ export namespace Thermostat {
 			label: "Query";
 			name: "query";
 		};
-		ADRPST: ((value: ) => Promise<boolean>) & {
+		ADRPST: ((value: (0 | 1)) => Promise<boolean>) & {
 			label: "ADR";
 			name: "adr";
 		};
 	};
 	export type Drivers = {
 		ST: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.Degree;
+			value: number;
 			label: "Temperature";
 			name: "temperature";
 		};
 		CLISPH: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.Degree;
+			value: number;
 			label: "Heat Setpoint";
 			name: "heatSetpoint";
 		};
 		CLISPC: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.Degree;
+			value: number;
 			label: "Cool Setpoint";
 			name: "coolSetpoint";
 		};
 		CLIMD: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.ThermostatMode;
+			value: number;
 			label: "Mode";
 			name: "mode";
 		};
 		CLIFS: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.ThermostatFanMode;
+			value: (0 | 1);
 			label: "Fan Mode";
 			name: "fanMode";
 		};
 		CLIHCS: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.ThermostatHeatCoolState;
+			value: number;
 			label: "Heat/Cool State";
 			name: "heatCoolState";
 		};
 		CLIFRS: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.ThermostatFanRunState;
+			value: (0 | 1);
 			label: "Fan State";
 			name: "fanState";
 		};
 		CLISMD: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.Index;
+			value: number;
 			label: "Schedule Mode";
 			name: "scheduleMode";
 		};
 		ERR: {
-			uom: ;
-			value: ;
+			uom: UnitOfMeasure.Index;
+			value: ZigBeeLegacy.Error;
 			label: "Responding";
 			name: "responding";
 		};

package/src/ISY.ts

@@ -23,12 +23,11 @@ import * as Utils from './Utils.js';
 import { X2jOptions, XMLParser } from 'fast-xml-parser';
 import type { ClientRequestArgs } from 'http';
 import path from 'path';
-import { textChangeRangeIsUnchanged } from 'typescript';
-import { promisify } from 'util';
 import { NodeFactory } from './Devices/NodeFactory.js';
 import { ISYError } from './ISYError.js';
 import type { Config } from './Model/Config.js';
 import { findPackageJson } from './Utils.js';
+import { GenericNode } from './Devices/GenericNode.js';
 
 type InitStep = 'config' | 'loadNodes' | 'readFolders' | 'readDevices' | 'readScenes' | 'variables' | 'websocket' | 'refreshStatuses' | 'initialize';
 
@@ -541,7 +540,7 @@ export class ISY extends EventEmitter implements Disposable {
 			for (const node of result.nodes.node) {
 				let device = that.getNode(node.id) as unknown as ISYNode<any, any, any, any>;
 				if (device !== null && device !== undefined) {
-					device.parseResult(node.property);
+					device.parseResult(node);
 				}
 			}
 		} catch (e) {
@@ -792,7 +791,7 @@ export class ISY extends EventEmitter implements Disposable {
 					if (enabled) {
 						if (newDevice === null) {
 							this.logger.warn(`Device type resolution failed for ${nodeInfo.name} with type: ${nodeInfo.type} and nodedef: ${nodeInfo.nodeDefId}`);
-							newDevice = new ISYDeviceNode<any, any, any, any>(this, nodeInfo);
+							newDevice = new GenericNode(this, nodeInfo);
 						} else if (newDevice !== null) {
 							if (m.unsupported) {
 								this.logger.warn('Device not currently supported: ' + JSON.stringify(nodeInfo) + ' /n It has been mapped to: ' + d.name);

package/src/ISYConstants.ts

@@ -154,10 +154,6 @@ const ISYConstants = {
 
 };
 
-export const Properties =
-{
-
-}
 
 export enum VariableType {
 	Integer = 1,
@@ -174,9 +170,3 @@ export enum LinkType
 	Controller = 16,
 	Responder = 0
 }
-
-
-export default ISYConstants;
-export const Props = ISYConstants.Props;
-export const States = ISYConstants.States;
-export const Commands = ISYConstants.Cmds;

package/src/ISYNode.ts

@@ -156,16 +156,21 @@ export class ISYNode<
 	}
 
 	public applyStatus(prop: DriverState) {
+		try {
 		var d = this.drivers[prop.id];
 
 		if (d) {
 			d.apply(prop);
 
-			this.logger(`Property ${d.label} (${prop.id}) refreshed to: ${d.value} (${d.state.formattedValue}})`);
+			this.logger(`Property ${d?.label ?? prop.id} (${prop.id}) refreshed to: ${d.value} (${prop.formatted}})`);
 			//d.state.value = this.convertFrom(prop.value, prop.uom, prop.id);
 			//d.state.formatted = prop.formatted;
 			//d.state.uom = prop.uom;
 		}
+		}
+		catch(e) {
+			this.logger(e?.message ?? e, 'error');
+		}
 	}
 
 	public convert(value: any, from: UnitOfMeasure, to: UnitOfMeasure): any {
@@ -369,7 +374,7 @@ export class ISYNode<
 				return this.isy.sendNodeCommand(this, command, { default: valueOrParameters, ...parameters });
 			}
 
-		
+
 
 	}
 

package/src/ISYScene.ts

@@ -3,7 +3,7 @@ import type { Driver } from './Definitions/Global/Drivers.js';
 import { Family } from './Definitions/Global/Families.js';
 import {Insteon} from './Devices/index.js';
 import type { ISY } from './ISY.js';
-import { Commands, LinkType } from './ISYConstants.js';
+import {  LinkType } from './ISYConstants.js';
 import { ISYDevice } from './ISYDevice.js';
 import { ISYNode } from './ISYNode.js';
 import type { NodeInfo, StaticNodeInfo } from './Model/NodeInfo.js';
@@ -123,10 +123,10 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>, Com
 		}
 	}
 	public async updateIsOn(lightState: boolean) {
-		return this.isy.sendNodeCommand(this, lightState ? Commands.On : Commands.Off);
+		return this.isy.sendNodeCommand(this, lightState ? 'DON' : 'DOF');
 	}
 	public async updateBrightnessLevel(level) {
-		return this.isy.sendNodeCommand(this, level > 0 ? Commands.On : Commands.Off, level);
+		return this.isy.sendNodeCommand(this, level > 0 ? 'DON' : 'DOF', level);
 	}
 	public getAreAllLightsInSpecifiedState(state) {
 		for (const device of this.members) {