isy-nodejs 1.0.2-alpha.4 → 1.0.3-alpha.0

package/src/Devices/Lutron/Generated/LoadShed.ts

@@ -31,7 +31,7 @@ export class LoadShedNode extends Base<Drivers, Commands> implements LoadShed.In
 		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(value?: (0 | 100)) { return this.sendCommand("DON", { value: value }); }
+	async on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
 	async query() { return this.sendCommand("QUERY"); }
 	public get status(): (0 | 100) {
@@ -48,7 +48,9 @@ export namespace LoadShed {
 	export interface Interface extends Omit<InstanceType<typeof LoadShedNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "LUTLoadShed";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is LoadShedNode { return ["LUTLoadShed"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is LoadShedNode {
+		return ["LUTLoadShed"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is LoadShedNode {
 		return ["LUTLoadShed"].includes(node.nodeDefId);
 	}

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

@@ -35,7 +35,7 @@ export class RelayNode extends Base<Drivers, Commands> implements Relay.Interfac
 	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: value }); }
+	async adr(value: (0 | 1)) { return this.sendCommand("ADRPST", value); }
 	public get status(): (0 | 100) {
 		return this.drivers.ST?.value;
 	}
@@ -50,7 +50,9 @@ export namespace Relay {
 	export interface Interface extends Omit<InstanceType<typeof RelayNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "NCDRelay";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayNode { return ["NCDRelay"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is RelayNode {
+		return ["NCDRelay"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayNode {
 		return ["NCDRelay"].includes(node.nodeDefId);
 	}

package/src/Devices/Poly/Generated/MatterBridge.ts

@@ -47,7 +47,9 @@ export namespace MatterBridge {
 	export interface Interface extends Omit<InstanceType<typeof MatterBridgeNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "CONTROLLER";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is MatterBridgeNode { return ["CONTROLLER"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is MatterBridgeNode {
+		return ["CONTROLLER"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is MatterBridgeNode {
 		return ["CONTROLLER"].includes(node.nodeDefId);
 	}

package/src/Devices/Scene/Generated/Scene.ts

@@ -43,7 +43,7 @@ export class SceneNode extends Base<Drivers, Commands> implements Scene.Interfac
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
 	}
-	async on(value?: number) { return this.sendCommand("DON", { value: value }); }
+	async on(value?: number) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
 	async fastOff() { return this.sendCommand("DFOF"); }
 	async fastOn() { return this.sendCommand("DFON"); }
@@ -54,12 +54,12 @@ export class SceneNode extends Base<Drivers, Commands> implements Scene.Interfac
 	async fadeStop() { return this.sendCommand("FDSTOP"); }
 	async beep() { return this.sendCommand("BEEP"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async mode(value: number) { return this.sendCommand("CLIMD", { value: value }); }
-	async fanMode(value: (0 | 1)) { return this.sendCommand("CLIFS", { value: value }); }
-	async heatSetpoint(value: number) { return this.sendCommand("CLISPH", { value: value }); }
-	async coolSetpoint(value: number) { return this.sendCommand("CLISPC", { value: value }); }
-	async heatSetpointShift(value: number) { return this.sendCommand("CLISPHD", { value: value }); }
-	async coolSetpointShift(value: number) { return this.sendCommand("CLISPCD", { value: value }); }
+	async mode(value: number) { return this.sendCommand("CLIMD", value); }
+	async fanMode(value: (0 | 1)) { return this.sendCommand("CLIFS", value); }
+	async heatSetpoint(value: number) { return this.sendCommand("CLISPH", value); }
+	async coolSetpoint(value: number) { return this.sendCommand("CLISPC", value); }
+	async heatSetpointShift(value: number) { return this.sendCommand("CLISPHD", value); }
+	async coolSetpointShift(value: number) { return this.sendCommand("CLISPCD", value); }
 }
 
 NodeFactory.register(SceneNode);
@@ -68,7 +68,9 @@ export namespace Scene {
 	export interface Interface extends Omit<InstanceType<typeof SceneNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "InsteonDimmer";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is SceneNode { return ["InsteonDimmer"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is SceneNode {
+		return ["InsteonDimmer"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is SceneNode {
 		return ["InsteonDimmer"].includes(node.nodeDefId);
 	}

package/src/Devices/UDI/Generated/Channel.ts

@@ -45,7 +45,9 @@ export namespace Channel {
 	export interface Interface extends Omit<InstanceType<typeof ChannelNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EM3Channel";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is ChannelNode { return ["EM3Channel"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is ChannelNode {
+		return ["EM3Channel"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ChannelNode {
 		return ["EM3Channel", "EM3Main", "EM3MainChannel"].includes(node.nodeDefId);
 	}

package/src/Devices/UDI/Generated/Em3MainChannel.ts

@@ -57,7 +57,9 @@ export namespace Em3MainChannel {
 	export interface Interface extends Omit<InstanceType<typeof Em3MainChannelNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EM3MainChannel";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is Em3MainChannelNode { return ["EM3MainChannel"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is Em3MainChannelNode {
+		return ["EM3MainChannel"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Em3MainChannelNode {
 		return ["EM3MainChannel"].includes(node.nodeDefId);
 	}

package/src/Devices/UDI/Generated/Main.ts

@@ -48,7 +48,9 @@ export namespace Main {
 	export interface Interface extends Omit<InstanceType<typeof MainNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EM3Main";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is MainNode { return ["EM3Main"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is MainNode {
+		return ["EM3Main"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is MainNode {
 		return ["EM3Main"].includes(node.nodeDefId);
 	}

package/src/Devices/UDI/Generated/PulseCounter.ts

@@ -49,7 +49,9 @@ export namespace PulseCounter {
 	export interface Interface extends Omit<InstanceType<typeof PulseCounterNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EM3PulseCounter";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is PulseCounterNode { return ["EM3PulseCounter"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is PulseCounterNode {
+		return ["EM3PulseCounter"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is PulseCounterNode {
 		return ["EM3PulseCounter"].includes(node.nodeDefId);
 	}

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

@@ -48,7 +48,9 @@ export namespace Relay {
 	export interface Interface extends Omit<InstanceType<typeof RelayNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EM3Relay";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayNode { return ["EM3Relay"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is RelayNode {
+		return ["EM3Relay"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayNode {
 		return ["EM3Relay"].includes(node.nodeDefId);
 	}

package/src/Devices/UDI/Generated/TemperatureSensor.ts

@@ -41,7 +41,9 @@ export namespace TemperatureSensor {
 	export interface Interface extends Omit<InstanceType<typeof TemperatureSensorNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "EM3TempSensor";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is TemperatureSensorNode { return ["EM3TempSensor"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is TemperatureSensorNode {
+		return ["EM3TempSensor"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is TemperatureSensorNode {
 		return ["EM3TempSensor"].includes(node.nodeDefId);
 	}

package/src/Devices/ZWave/Generated/ColorSwitch.ts

@@ -34,10 +34,11 @@ export class ColorSwitchNode extends Base<Drivers, Commands> implements ColorSwi
 		this.drivers.GV2 = Driver.create("GV2", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Red", name: "red" });
 		this.drivers.GV3 = Driver.create("GV3", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Green", name: "green" });
 		this.drivers.GV4 = Driver.create("GV4", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Blue", name: "blue" });
+		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Cold White", name: "coldWhite" });
 	}
-	async set(warmWhite?: number, red?: number, green?: number, blue?: number, duration?: number | number) { return this.sendCommand("DON", { GV0: warmWhite, GV2: red, GV3: green, GV4: blue, RR: duration }); }
-	async fadeUp(component: ZWave.ColorComponent, startLevel?: number, duration?: number | number) { return this.sendCommand("FDUP", { ID: component, STARTLEVEL: startLevel, RR: duration }); }
-	async fadeDown(component: ZWave.ColorComponent, startLevel?: number, duration?: number | number) { return this.sendCommand("FDDOWN", { ID: component, STARTLEVEL: startLevel, RR: duration }); }
+	async set(warmWhite?: number, red?: number, green?: number, blue?: number, duration?: number, coldWhite?: number) { return this.sendCommand("DON", { GV0: warmWhite, GV2: red, GV3: green, GV4: blue, RR: duration, GV1: coldWhite }); }
+	async fadeUp(component: ZWave.ColorComponent, startLevel?: number, duration?: number) { return this.sendCommand("FDUP", { ID: component, STARTLEVEL: startLevel, RR: duration }); }
+	async fadeDown(component: ZWave.ColorComponent, startLevel?: number, duration?: number) { return this.sendCommand("FDDOWN", { ID: component, STARTLEVEL: startLevel, RR: duration }); }
 	async fadeStop(component: ZWave.ColorComponent) { return this.sendCommand("FDSTOP", { ID: component }); }
 	async query() { return this.sendCommand("QUERY"); }
 	public get warmWhite(): number {
@@ -52,6 +53,9 @@ export class ColorSwitchNode extends Base<Drivers, Commands> implements ColorSwi
 	public get blue(): number {
 		return this.drivers.GV4?.value;
 	}
+	public get coldWhite(): number {
+		return this.drivers.GV1?.value;
+	}
 }
 
 NodeFactory.register(ColorSwitchNode);
@@ -60,7 +64,9 @@ export namespace ColorSwitch {
 	export interface Interface extends Omit<InstanceType<typeof ColorSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "186";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is ColorSwitchNode { return ["186"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is ColorSwitchNode {
+		return ["186"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ColorSwitchNode {
 		return ["186"].includes(node.nodeDefId);
 	}
@@ -69,15 +75,15 @@ export namespace ColorSwitch {
 	}
 	export const Node = ColorSwitchNode;
 	export type Commands = {
-		DON: ((GV0?: number, GV2?: number, GV3?: number, GV4?: number, RR?: number | number) => Promise<boolean>) & {
+		DON: ((GV0?: number, GV2?: number, GV3?: number, GV4?: number, RR?: number, GV1?: number) => Promise<boolean>) & {
 			label: "Set";
 			name: "set";
 		};
-		FDUP: ((ID: ZWave.ColorComponent, STARTLEVEL?: number, RR?: number | number) => Promise<boolean>) & {
+		FDUP: ((ID: ZWave.ColorComponent, STARTLEVEL?: number, RR?: number) => Promise<boolean>) & {
 			label: "Fade Up";
 			name: "fadeUp";
 		};
-		FDDOWN: ((ID: ZWave.ColorComponent, STARTLEVEL?: number, RR?: number | number) => Promise<boolean>) & {
+		FDDOWN: ((ID: ZWave.ColorComponent, STARTLEVEL?: number, RR?: number) => Promise<boolean>) & {
 			label: "Fade Down";
 			name: "fadeDown";
 		};
@@ -115,5 +121,11 @@ export namespace ColorSwitch {
 			label: "Blue";
 			name: "blue";
 		};
+		GV1: {
+			uom: UnitOfMeasure.Raw1ByteUnsignedValue;
+			value: number;
+			label: "Cold White";
+			name: "coldWhite";
+		};
 	};
 }

package/src/Devices/ZWave/Generated/DimmerSwitch.ts

@@ -41,18 +41,18 @@ export class DimmerSwitchNode extends Base<Drivers, Commands> implements DimmerS
 		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(value?: ZWave.PercentOpt | number, rampRate?: number | number) { return this.sendCommand("DON", { value: value, RR: rampRate }); }
+	async on(value?: number | ZWave.PercentOpt, rampRate?: number) { return this.sendCommand("DON", value, { RR: rampRate }); }
 	async off() { return this.sendCommand("DOF"); }
 	async fastOn() { return this.sendCommand("DFON"); }
 	async fastOff() { return this.sendCommand("DFOF"); }
 	async brighten() { return this.sendCommand("BRT"); }
 	async dim() { return this.sendCommand("DIM"); }
-	async fadeUp(startLevel?: ZWave.PercentOpt | number, rampRate?: number | number) { return this.sendCommand("FDUP", { STARTLEVEL: startLevel, RR: rampRate }); }
-	async fadeDown(startLevel?: ZWave.PercentOpt | number, rampRate?: number | number) { return this.sendCommand("FDDOWN", { STARTLEVEL: startLevel, RR: rampRate }); }
-	async fade(direction: ZWave.FadeDirection, startLevel?: ZWave.PercentOpt | number, rampRate?: number | number, direction2?: ZWave.FadeDirection, fadeRate2?: number | number) { return this.sendCommand("FADE", { DIR: direction, STARTLEVEL: startLevel, RR: rampRate, DIR2: direction2, STEP2: fadeRate2 }); }
+	async fadeUp(startLevel?: number | ZWave.PercentOpt, rampRate?: number) { return this.sendCommand("FDUP", { STARTLEVEL: startLevel, RR: rampRate }); }
+	async fadeDown(startLevel?: number | ZWave.PercentOpt, rampRate?: number) { return this.sendCommand("FDDOWN", { STARTLEVEL: startLevel, RR: rampRate }); }
+	async fade(direction: ZWave.FadeDirection, startLevel?: number | ZWave.PercentOpt, rampRate?: number, direction2?: ZWave.FadeDirection, fadeRate2?: number) { return this.sendCommand("FADE", { DIR: direction, STARTLEVEL: startLevel, RR: rampRate, DIR2: direction2, STEP2: fadeRate2 }); }
 	async fadeStop() { return this.sendCommand("FDSTOP"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async setConfiguration(parameterNumber: number, parameterValue: number | number | number | number | number | number) { return this.sendCommand("CONFIG", { NUM: parameterNumber, VAL: parameterValue }); }
+	async setConfiguration(parameterNumber: number, parameterValue: number) { return this.sendCommand("CONFIG", { NUM: parameterNumber, VAL: parameterValue }); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -68,7 +68,9 @@ export namespace DimmerSwitch {
 	export interface Interface extends Omit<InstanceType<typeof DimmerSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "119";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode { return ["119"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode {
+		return ["119"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode {
 		return ["119"].includes(node.nodeDefId);
 	}
@@ -77,7 +79,7 @@ export namespace DimmerSwitch {
 	}
 	export const Node = DimmerSwitchNode;
 	export type Commands = {
-		DON: ((value?: ZWave.PercentOpt | number, RR?: number | number) => Promise<boolean>) & {
+		DON: ((value?: number | ZWave.PercentOpt, RR?: number) => Promise<boolean>) & {
 			label: "On";
 			name: "on";
 		};
@@ -101,15 +103,15 @@ export namespace DimmerSwitch {
 			label: "Dim";
 			name: "dim";
 		};
-		FDUP: ((STARTLEVEL?: ZWave.PercentOpt | number, RR?: number | number) => Promise<boolean>) & {
+		FDUP: ((STARTLEVEL?: number | ZWave.PercentOpt, RR?: number) => Promise<boolean>) & {
 			label: "Fade Up";
 			name: "fadeUp";
 		};
-		FDDOWN: ((STARTLEVEL?: ZWave.PercentOpt | number, RR?: number | number) => Promise<boolean>) & {
+		FDDOWN: ((STARTLEVEL?: number | ZWave.PercentOpt, RR?: number) => Promise<boolean>) & {
 			label: "Fade Down";
 			name: "fadeDown";
 		};
-		FADE: ((DIR: ZWave.FadeDirection, STARTLEVEL?: ZWave.PercentOpt | number, RR?: number | number, DIR2?: ZWave.FadeDirection, STEP2?: number | number) => Promise<boolean>) & {
+		FADE: ((DIR: ZWave.FadeDirection, STARTLEVEL?: number | ZWave.PercentOpt, RR?: number, DIR2?: ZWave.FadeDirection, STEP2?: number) => Promise<boolean>) & {
 			label: "Fade";
 			name: "fade";
 		};
@@ -121,7 +123,7 @@ export namespace DimmerSwitch {
 			label: "Query";
 			name: "query";
 		};
-		CONFIG: ((NUM: number, VAL: number | number | number | number | number | number) => Promise<boolean>) & {
+		CONFIG: ((NUM: number, VAL: number) => Promise<boolean>) & {
 			label: "Set Configuration";
 			name: "setConfiguration";
 		};

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

@@ -35,7 +35,7 @@ export class RelayNode extends Base<Drivers, Commands> implements Relay.Interfac
 	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: value }); }
+	async adr(value: ) { return this.sendCommand("ADRPST", value); }
 	public get status(): {
         
 return this.drivers.ST?.value;
@@ -53,7 +53,9 @@ export namespace Relay {
 	export interface Interface extends Omit<InstanceType<typeof RelayNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "RelayLoadControl";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayNode { return ["RelayLoadControl"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is RelayNode {
+		return ["RelayLoadControl"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayNode {
 		return ["RelayLoadControl"].includes(node.nodeDefId);
 	}

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

@@ -44,15 +44,15 @@ export class ThermostatNode extends Base<Drivers, Commands> implements Thermosta
 		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" });
 	}
-	async updateHeatSetpoint(value: ) { return this.sendCommand("CLISPH", { value: value }); }
-	async updateCoolSetpoint(value: ) { return this.sendCommand("CLISPC", { value: value }); }
-	async updateMode(value: ) { return this.sendCommand("CLIMD", { value: value }); }
-	async updateFanMode(value: ) { return this.sendCommand("CLIFS", { value: value }); }
-	async updateScheduleMode(value: ) { return this.sendCommand("CLISMD", { value: value }); }
-	async heatSetpointShift(value: ) { return this.sendCommand("CLISPHD", { value: value }); }
-	async coolSetpointShift(value: ) { return this.sendCommand("CLISPCD", { value: value }); }
+	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 query() { return this.sendCommand("QUERY"); }
-	async adr(value: ) { return this.sendCommand("ADRPST", { value: value }); }
+	async adr(value: ) { return this.sendCommand("ADRPST", value); }
 	public get temperature(): {
         
 return this.drivers.ST?.value;
@@ -105,7 +105,9 @@ export namespace Thermostat {
 	export interface Interface extends Omit<InstanceType<typeof ThermostatNode>, keyof ISYDeviceNode<any, any, any, any>> {
 		nodeDefId: "Thermostat";
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is ThermostatNode { return ["Thermostat"].includes(node.nodeDefId); }
+	export function is(node: ISYNode<any, any, any, any>): node is ThermostatNode {
+		return ["Thermostat"].includes(node.nodeDefId);
+	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ThermostatNode {
 		return ["Thermostat"].includes(node.nodeDefId);
 	}

package/src/ISY.ts

@@ -1,9 +1,9 @@
-import WebSocket from 'faye-websocket';
+
 import { writeFile } from 'fs';
 
 import { Parser, type ParserOptions } from 'xml2js';
 import { parseBooleans, parseNumbers } from 'xml2js/lib/processors.js';
-
+import WebSocket from 'ws';
 import axios, { type AxiosRequestConfig } from 'axios';
 import { EventEmitter } from 'events';
 import { format, Logger, loggers, type LeveledLogMethod } from 'winston';
@@ -27,6 +27,9 @@ import { NodeFactory } from './Devices/NodeFactory.js';
 import { ISYError } from './ISYError.js';
 import type { Config } from './Model/Config.js';
 import { findPackageJson } from './Utils.js';
+import { textChangeRangeIsUnchanged } from 'typescript';
+import type { ClientRequestArgs } from 'http';
+import { promisify } from 'util';
 
 
 
@@ -94,9 +97,9 @@ interface ISYConfig {
 	port: number;
 	protocol: 'http' | 'https';
 	username: string;
-
 	socketPath?: string;
-
+	axiosOptions?: AxiosRequestConfig;
+	webSocketOptions?: WebSocket.ClientOptions & ClientRequestArgs;
 	// #endregion Properties (8)
 }
 
@@ -135,7 +138,7 @@ export class ISY extends EventEmitter implements Disposable {
 	public productName = 'eisy';
 	public firmwareVersion: any;
 	public vendorName = 'Universal Devices, Inc.';
-	public webSocket: WebSocket.Client;
+	public webSocket: WebSocket;
 
 	public apiVersion: string;
 
@@ -162,7 +165,7 @@ export class ISY extends EventEmitter implements Disposable {
 		};
 		this.protocol = config.protocol;
 		this.wsprotocol = config.protocol === 'https' ? 'wss' : 'ws';
-
+		this.socketPath = config.socketPath;
 		this.axiosOptions = {
 			baseURL: `${this.protocol}://${this.host}:${this.port}`,
 			validateStatus: (status) => status >= 200 && status < 300
@@ -174,6 +177,15 @@ export class ISY extends EventEmitter implements Disposable {
 			this.axiosOptions.auth = { username: this.credentials.username, password: this.credentials.password };
 		}
 
+		this.webSocketOptions = { origin: 'com.universal-devices.websockets.isy' };
+
+		if (this.socketPath) {
+			this.webSocketOptions.socketPath = this.socketPath;
+		} else {
+			this.webSocketOptions.auth = `${this.credentials.username}:${this.credentials.password}`;
+		}
+
+
 		//this.elkEnabled = config.elkEnabled ?? false;
 
 		this.nodesLoaded = false;
@@ -355,29 +367,40 @@ export class ISY extends EventEmitter implements Disposable {
 		try {
 			await this.loadConfig();
 			await this.loadNodes();
+			await this.refreshStatuses();
 			await this.loadVariables(VariableType.Integer);
 			await this.loadVariables(VariableType.State);
-			await this.refreshStatuses();
 			await this.#finishInitialize(true);
 			return true;
 		} catch (e) {
 			if (e instanceof ISYInitializationError) {
+				if(e.step === 'variables')
+				{
+					this.logger.warn(`Error loading variables: ${e.message}`);
+				    await this.#finishInitialize(true);
+					return true;
+				}
 				this.logger.error(`Error initializing ISY during (${e.step}): ${e.message}`);
+				return false;
 			} else {
 				this.logger.error(`Error initializing ISY: ${e.message}`);
+				return false;
 			}
 			throw e;
 		} finally {
 			if (this.nodesLoaded !== true) {
-				that.#finishInitialize(false);
+				await that.#finishInitialize(false);
 			}
 		}
 	}
 
+	webSocketOptions: WebSocket.ClientOptions & ClientRequestArgs;
+
 	public async initializeWebSocket() {
 		try {
 			const that = this;
-			const auth = `Basic ${Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64')}`;
+
+			//const auth = `Basic ${Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64')}`;
 			this.logger.info(`Opening webSocket: ${this.wsprotocol}://${this.address}/rest/subscribe`);
 			if (this.webSocket) {
 				try {
@@ -386,27 +409,33 @@ export class ISY extends EventEmitter implements Disposable {
 					this.logger.warn(`Error closing existing websocket: ${e.message}`);
 				}
 			}
-			this.webSocket = new WebSocket.Client(`${this.wsprotocol}://${this.address}/rest/subscribe`, ['ISYSUB'], {
-				headers: {
+
+				/*headers: {
 					Origin: 'com.universal-devices.websockets.isy',
-					Authorization: auth
+					auth
 				},
-				ping: 10
-			});
 
-			this.lastActivity = new Date();
+				ping: 10*/
+			let p  = new Promise<void>((resolve, reject) => {
 
-			this.webSocket
-				.on('message', (event: any) => {
-					that.logger.silly(`Received message: ${Utils.logStringify(event.data, 1)}`);
-					that.handleWebSocketMessage(event);
+			this.webSocket = new WebSocket(`${this.wsprotocol}://${this.address}/rest/subscribe`, ['ISYSUB'], this.webSocketOptions);
+			this.lastActivity = new Date();
+			//this.webSocket.onmessage = (event) => {this.handleWebSocketMessage()
+			this.webSocket.on('open',() => {
+				this.logger.info('Websocket connection open');
+				resolve();
+			})
+				.on('message',(data,b)=> {
+					that.logger.silly(`Received message: ${Utils.logStringify(data, 1)}`);
+					that.handleWebSocketMessage({data: data});
 				})
 				.on('error', (err: any, response: any) => {
-					that.logger.warn(`Websocket subscription error: ${Utils.logStringify(err, 1)}`);
+					that.logger.warn(`Websocket subscription error: ${err}`);
+					return reject(new ISYInitializationError('Websocket subscription error', 'websocket'));
 				})
 				.on('fail', (data: string, response: any) => {
 					that.logger.warn(`Websocket subscription failure: ${data}`);
-					throw new Error('Websocket subscription failure');
+					return reject(new Error('Websocket subscription failure'));
 				})
 				.on('abort', () => {
 					that.logger.warn('Websocket subscription aborted.');
@@ -414,8 +443,11 @@ export class ISY extends EventEmitter implements Disposable {
 				})
 				.on('timeout', (ms: string) => {
 					that.logger.warn(`Websocket subscription timed out after ${ms} milliseconds.`);
-					throw new Error('Timeout contacting ISY');
+					return reject(new Error('Timeout contacting ISY'));
+					//throw new Error('Timeout contacting ISY');
 				});
+			});
+			return p;
 		} catch (e) {
 			throw new ISYInitializationError(e, 'websocket');
 		}
@@ -538,7 +570,7 @@ export class ISY extends EventEmitter implements Disposable {
 			if (typeof parameters == 'object') {
 				var q = parameters as Record<P, string | number>;
 				for (const paramName in q) {
-					if (paramName === 'value') {
+					if (paramName === 'value' || paramName === 'default') {
 						uriToUse += `/${q[paramName]}`;
 						continue;
 					}
@@ -646,7 +678,7 @@ export class ISY extends EventEmitter implements Disposable {
 		}
 	}
 
-	#finishInitialize(success: boolean) {
+	async #finishInitialize(success: boolean) {
 		if (!this.nodesLoaded) {
 			this.nodesLoaded = true;
 			//initializeCompleted();
@@ -656,10 +688,11 @@ export class ISY extends EventEmitter implements Disposable {
 				// }
 				if (this.enableWebSocket) {
 					this.guardianTimer = setInterval(this.#guardian.bind(this), 60000);
-					this.initializeWebSocket();
+					return this.initializeWebSocket();
 				}
 			}
 		}
+
 	}
 
 	async #guardian() {

package/src/Matter/Behaviors/ISYBridgedDeviceBehavior.ts

@@ -11,10 +11,10 @@ import internal from 'stream';
 import type { Driver } from '../../Definitions/Global/Drivers.js';
 import { ISY } from '../../ISY.js';
 import type { ISYDevice } from '../../ISYDevice.js';
-import { DeviceToClusterMap, MappingRegistry, type ClusterMapping, type BehaviorMapping } from '../../Model/ClusterMap.js';
 import { server } from 'typescript';
 import type { ISYNode } from '../../ISYNode.js';
 import type { Family } from '../../Definitions/index.js';
+import { MappingRegistry, type BehaviorMapping, type DeviceToClusterMap } from '../Mappings/MappingRegistry.js';
 
 
 

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -4,8 +4,9 @@ import '@project-chip/matter.js/device';
 import { Converter } from '../../Converters.js';
 import type { Constructor } from '../../Devices/Constructor.js';
 import type { DriversOf, ISYNode } from '../../ISYNode.js';
-import { BehaviorMapping } from '../../Model/ClusterMap.js';
+
 import { ISYBridgedDeviceBehavior } from './ISYBridgedDeviceBehavior.js';
+import type { BehaviorMapping } from '../Mappings/MappingRegistry.js';
 
 // #region Type aliases (6)
 

package/src/Matter/Behaviors/Insteon/ISYOnOffBehavior.ts

@@ -8,7 +8,7 @@ import type { MaybePromise } from '@project-chip/matter.js/util';
 import { DriverType } from '../../../Definitions/Global/Drivers.js';
 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 { Converter } from '../../../Converters.js';
@@ -53,6 +53,7 @@ export class ISYDimmableBehavior extends ISYClusterBehavior(DimmableLightRequire
 
 	override setLevel(level: number): MaybePromise<void> {
 		level = Converter.Matter.LevelFrom0To255.LightingLevel.from(level);
+		
 		if (level > 0) {
 			return this.device.on(level);
 		} else {