isy-nodejs 1.0.6-alpha.2 → 1.0.8-alpha.0

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

@@ -17,19 +17,19 @@ const nodeDefId = "LUTLoadShed";
 type Commands = LoadShed.Commands;
 type Drivers = LoadShed.Drivers;
 
-export class LoadShedNode extends Base<Drivers, Commands> implements LoadShed.Interface {
+class LoadShedNode extends Base<Drivers, Commands> implements LoadShed.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		QUERY: this.query
 	};
 	static override nodeDefId = "LUTLoadShed";
-	static override implements = ["LUTLoadShed"];
-	declare readonly nodeDefId: "LUTLoadShed";
+	static override implements = ['LUTLoadShed'];
+	declare readonly nodeDefId: 'LUTLoadShed';
 	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.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: (0 | 100)) { return this.sendCommand("DON", value); }
 	async off() { return this.sendCommand("DOF"); }
@@ -46,13 +46,12 @@ NodeFactory.register(LoadShedNode);
 
 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);
+		return ['LUTLoadShed'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is LoadShedNode {
-		return ["LUTLoadShed"].includes(node.nodeDefId);
+		return ['LUTLoadShed'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new LoadShedNode(isy, nodeInfo);

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

@@ -17,7 +17,7 @@ const nodeDefId = "NCDRelay";
 type Commands = Relay.Commands;
 type Drivers = Relay.Drivers;
 
-export class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
+class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -25,39 +25,35 @@ export class RelayNode extends Base<Drivers, Commands> implements Relay.Interfac
 		ADRPST: this.adr
 	};
 	static override nodeDefId = "NCDRelay";
-	static override implements = ["NCDRelay"];
-	declare readonly nodeDefId: "NCDRelay";
+	static override implements = ['NCDRelay'];
+	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.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.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { 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(): NCD.Error {
+		return this.drivers.ERR?.value;
+	}
 }
 
 NodeFactory.register(RelayNode);
 
 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);
+		return ['NCDRelay'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayNode {
-		return ["NCDRelay"].includes(node.nodeDefId);
+		return ['NCDRelay'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayNode(isy, nodeInfo);
@@ -76,21 +72,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: NCD.Error;
 			label: "Responding";
 			name: "responding";
 		};

package/src/Devices/NodeFactory.ts

@@ -54,7 +54,7 @@ export namespace NodeFactory {
 		}
 	}
 
-	export function getImplements<F extends keyof typeof Family, T extends ISYNode<typeof Family[F],any,any,any>>(node: T) {
+	export function getImplements<F extends keyof typeof Family, T extends ISYNode<typeof Family[F],any,any,any>>(node: T | typeof ISYNode) : string[] {
 		return implementsRegistry[Family[node.family] as F][node.nodeDefId];
 	}
 

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

@@ -17,7 +17,7 @@ const nodeDefId = "CONTROLLER";
 type Commands = MatterBridge.Commands;
 type Drivers = MatterBridge.Drivers;
 
-export class MatterBridgeNode extends Base<Drivers, Commands> implements MatterBridge.Interface {
+class MatterBridgeNode extends Base<Drivers, Commands> implements MatterBridge.Interface {
 	public override readonly commands = {
 		DISCOVER: this.discover,
 		QUERY: this.query,
@@ -25,11 +25,11 @@ export class MatterBridgeNode extends Base<Drivers, Commands> implements MatterB
 		STOP_BRIDGE: this.stopBridge
 	};
 	static override nodeDefId = "CONTROLLER";
-	static override implements = ["CONTROLLER"];
-	declare readonly nodeDefId: "CONTROLLER";
+	static override implements = ['CONTROLLER'];
+	declare readonly nodeDefId: 'CONTROLLER';
 	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.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Unknown, label: "Status", name: "status" });
 	}
 	async discover() { return this.sendCommand("DISCOVER"); }
 	async query() { return this.sendCommand("QUERY"); }
@@ -45,13 +45,12 @@ NodeFactory.register(MatterBridgeNode);
 
 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);
+		return ['CONTROLLER'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is MatterBridgeNode {
-		return ["CONTROLLER"].includes(node.nodeDefId);
+		return ['CONTROLLER'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new MatterBridgeNode(isy, nodeInfo);

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

@@ -17,7 +17,7 @@ const nodeDefId = "InsteonDimmer";
 type Commands = Scene.Commands;
 type Drivers = Scene.Drivers;
 
-export class SceneNode extends Base<Drivers, Commands> implements Scene.Interface {
+class SceneNode extends Base<Drivers, Commands> implements Scene.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -38,8 +38,8 @@ export class SceneNode extends Base<Drivers, Commands> implements Scene.Interfac
 		CLISPCD: this.coolSetpointShift
 	};
 	static override nodeDefId = "InsteonDimmer";
-	static override implements = ["InsteonDimmer"];
-	declare readonly nodeDefId: "InsteonDimmer";
+	static override implements = ['InsteonDimmer'];
+	declare readonly nodeDefId: 'InsteonDimmer';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
 	}
@@ -66,13 +66,12 @@ NodeFactory.register(SceneNode);
 
 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);
+		return ['InsteonDimmer'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is SceneNode {
-		return ["InsteonDimmer"].includes(node.nodeDefId);
+		return ['InsteonDimmer'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new SceneNode(isy, nodeInfo);

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

@@ -17,16 +17,16 @@ const nodeDefId = "EM3Channel";
 type Commands = Channel.Commands;
 type Drivers = Channel.Drivers;
 
-export class ChannelNode extends Base<Drivers, Commands> implements Channel.Interface {
+class ChannelNode extends Base<Drivers, Commands> implements Channel.Interface {
 	public override readonly commands = {};
 	static override nodeDefId = "EM3Channel";
-	static override implements = ["EM3Channel"];
-	declare readonly nodeDefId: "EM3Channel";
+	static override implements = ['EM3Channel'];
+	declare readonly nodeDefId: 'EM3Channel';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Watt, label: "Status", name: "status" });
-		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
-		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.state['ST'], { uom: UnitOfMeasure.Watt, label: "Status", name: "status" });
+		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.state['TPW'], { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -43,13 +43,12 @@ NodeFactory.register(ChannelNode);
 
 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);
+		return ['EM3Channel'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ChannelNode {
-		return ["EM3Channel", "EM3Main", "EM3MainChannel"].includes(node.nodeDefId);
+		return ['EM3Channel', "EM3Main", "EM3MainChannel"].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new ChannelNode(isy, nodeInfo);

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

@@ -17,19 +17,19 @@ const nodeDefId = "EM3MainChannel";
 type Commands = Em3MainChannel.Commands;
 type Drivers = Em3MainChannel.Drivers;
 
-export class Em3MainChannelNode extends Base<Drivers, Commands> implements Em3MainChannel.Interface {
+class Em3MainChannelNode extends Base<Drivers, Commands> implements Em3MainChannel.Interface {
 	public override readonly commands = {};
 	static override nodeDefId = "EM3MainChannel";
-	static override implements = ["EM3MainChannel"];
-	declare readonly nodeDefId: "EM3MainChannel";
+	static override implements = ['EM3MainChannel'];
+	declare readonly nodeDefId: 'EM3MainChannel';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Watt, label: "Status", name: "status" });
-		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
-		this.drivers.CV = Driver.create("CV", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Volt, label: "Current Voltage", name: "currentVoltage" });
-		this.drivers.CC = Driver.create("CC", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Ampere, label: "Current Current", name: "currentCurrent" });
-		this.drivers.PF = Driver.create("PF", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.PowerFactor, label: "Power Factor", name: "powerFactor" });
-		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.state['ST'], { uom: UnitOfMeasure.Watt, label: "Status", name: "status" });
+		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.state['TPW'], { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
+		this.drivers.CV = Driver.create("CV", this, nodeInfo.state['CV'], { uom: UnitOfMeasure.Volt, label: "Current Voltage", name: "currentVoltage" });
+		this.drivers.CC = Driver.create("CC", this, nodeInfo.state['CC'], { uom: UnitOfMeasure.Ampere, label: "Current Current", name: "currentCurrent" });
+		this.drivers.PF = Driver.create("PF", this, nodeInfo.state['PF'], { uom: UnitOfMeasure.PowerFactor, label: "Power Factor", name: "powerFactor" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -55,13 +55,12 @@ NodeFactory.register(Em3MainChannelNode);
 
 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);
+		return ['EM3MainChannel'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Em3MainChannelNode {
-		return ["EM3MainChannel"].includes(node.nodeDefId);
+		return ['EM3MainChannel'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new Em3MainChannelNode(isy, nodeInfo);

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

@@ -17,18 +17,18 @@ const nodeDefId = "EM3Main";
 type Commands = Main.Commands;
 type Drivers = Main.Drivers;
 
-export class MainNode extends Base<Drivers, Commands> implements Main.Interface {
+class MainNode extends Base<Drivers, Commands> implements Main.Interface {
 	public override readonly commands = {
 		QUERY: this.query
 	};
 	static override nodeDefId = "EM3Main";
-	static override implements = ["EM3Main"];
-	declare readonly nodeDefId: "EM3Main";
+	static override implements = ['EM3Main'];
+	declare readonly nodeDefId: 'EM3Main';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Watt, label: "Status", name: "status" });
-		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
-		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.state['ST'], { uom: UnitOfMeasure.Watt, label: "Status", name: "status" });
+		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.state['TPW'], { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async query() { return this.sendCommand("QUERY"); }
 	public get status(): number {
@@ -46,13 +46,12 @@ NodeFactory.register(MainNode);
 
 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);
+		return ['EM3Main'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is MainNode {
-		return ["EM3Main"].includes(node.nodeDefId);
+		return ['EM3Main'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new MainNode(isy, nodeInfo);

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

@@ -17,17 +17,17 @@ const nodeDefId = "EM3PulseCounter";
 type Commands = PulseCounter.Commands;
 type Drivers = PulseCounter.Drivers;
 
-export class PulseCounterNode extends Base<Drivers, Commands> implements PulseCounter.Interface {
+class PulseCounterNode extends Base<Drivers, Commands> implements PulseCounter.Interface {
 	public override readonly commands = {};
 	static override nodeDefId = "EM3PulseCounter";
-	static override implements = ["EM3PulseCounter"];
-	declare readonly nodeDefId: "EM3PulseCounter";
+	static override implements = ['EM3PulseCounter'];
+	declare readonly nodeDefId: 'EM3PulseCounter';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.PulseCount, label: "Status", name: "status" });
-		this.drivers.CPW = Driver.create("CPW", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Watt, label: "Current Power", name: "currentPower" });
-		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
-		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.state['ST'], { uom: UnitOfMeasure.PulseCount, label: "Status", name: "status" });
+		this.drivers.CPW = Driver.create("CPW", this, nodeInfo.state['CPW'], { uom: UnitOfMeasure.Watt, label: "Current Power", name: "currentPower" });
+		this.drivers.TPW = Driver.create("TPW", this, nodeInfo.state['TPW'], { uom: UnitOfMeasure.KilowattsPerHour, label: "Total Energy", name: "totalEnergy" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	public get status(): number {
 		return this.drivers.ST?.value;
@@ -47,13 +47,12 @@ NodeFactory.register(PulseCounterNode);
 
 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);
+		return ['EM3PulseCounter'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is PulseCounterNode {
-		return ["EM3PulseCounter"].includes(node.nodeDefId);
+		return ['EM3PulseCounter'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new PulseCounterNode(isy, nodeInfo);

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

@@ -17,19 +17,19 @@ const nodeDefId = "EM3Relay";
 type Commands = Relay.Commands;
 type Drivers = Relay.Drivers;
 
-export class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
+class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		QUERY: this.query
 	};
 	static override nodeDefId = "EM3Relay";
-	static override implements = ["EM3Relay"];
-	declare readonly nodeDefId: "EM3Relay";
+	static override implements = ['EM3Relay'];
+	declare readonly nodeDefId: 'EM3Relay';
 	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.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on() { return this.sendCommand("DON"); }
 	async off() { return this.sendCommand("DOF"); }
@@ -46,13 +46,12 @@ NodeFactory.register(RelayNode);
 
 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);
+		return ['EM3Relay'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayNode {
-		return ["EM3Relay"].includes(node.nodeDefId);
+		return ['EM3Relay'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new RelayNode(isy, nodeInfo);

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

@@ -17,15 +17,15 @@ const nodeDefId = "EM3TempSensor";
 type Commands = TemperatureSensor.Commands;
 type Drivers = TemperatureSensor.Drivers;
 
-export class TemperatureSensorNode extends Base<Drivers, Commands> implements TemperatureSensor.Interface {
+class TemperatureSensorNode extends Base<Drivers, Commands> implements TemperatureSensor.Interface {
 	public override readonly commands = {};
 	static override nodeDefId = "EM3TempSensor";
-	static override implements = ["EM3TempSensor"];
-	declare readonly nodeDefId: "EM3TempSensor";
+	static override implements = ['EM3TempSensor'];
+	declare readonly nodeDefId: 'EM3TempSensor';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Degree, label: "Temperature", name: "temperature" });
-		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.state['ST'], { uom: UnitOfMeasure.Degree, label: "Temperature", name: "temperature" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	public get temperature(): number {
 		return this.drivers.ST?.value;
@@ -39,13 +39,12 @@ NodeFactory.register(TemperatureSensorNode);
 
 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);
+		return ['EM3TempSensor'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is TemperatureSensorNode {
-		return ["EM3TempSensor"].includes(node.nodeDefId);
+		return ['EM3TempSensor'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new TemperatureSensorNode(isy, nodeInfo);

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

@@ -1,5 +1,5 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
+/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
+
 import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
 import { Family } from "../../../Definitions/Global/Families.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
@@ -11,13 +11,13 @@ import { Driver } from "../../../Definitions/Global/Drivers.js";
 import { ZWave } from "../../../Definitions/index.js";
 import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
-
+
 const nodeDefId = "186";
-
+
 type Commands = ColorSwitch.Commands;
 type Drivers = ColorSwitch.Drivers;
-
-export class ColorSwitchNode extends Base<Drivers, Commands> implements ColorSwitch.Interface {
+
+class ColorSwitchNode extends Base<Drivers, Commands> implements ColorSwitch.Interface {
 	public override readonly commands = {
 		DON: this.set,
 		FDUP: this.fadeUp,
@@ -26,15 +26,15 @@ export class ColorSwitchNode extends Base<Drivers, Commands> implements ColorSwi
 		QUERY: this.query
 	};
 	static override nodeDefId = "186";
-	static override implements = ["186"];
-	declare readonly nodeDefId: "186";
+	static override implements = ['186'];
+	declare readonly nodeDefId: '186';
 	constructor (isy: ISY, nodeInfo: NodeInfo) {
 		super(isy, nodeInfo);
-		this.drivers.GV0 = Driver.create("GV0", this, nodeInfo.property as DriverState, { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Warm White", name: "warmWhite" });
-		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" });
+		this.drivers.GV0 = Driver.create("GV0", this, nodeInfo.state['GV0'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Warm White", name: "warmWhite" });
+		this.drivers.GV2 = Driver.create("GV2", this, nodeInfo.state['GV2'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Red", name: "red" });
+		this.drivers.GV3 = Driver.create("GV3", this, nodeInfo.state['GV3'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Green", name: "green" });
+		this.drivers.GV4 = Driver.create("GV4", this, nodeInfo.state['GV4'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Blue", name: "blue" });
+		this.drivers.GV1 = Driver.create("GV1", this, nodeInfo.state['GV1'], { uom: UnitOfMeasure.Raw1ByteUnsignedValue, label: "Cold White", name: "coldWhite" });
 	}
 	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 }); }
@@ -57,18 +57,17 @@ export class ColorSwitchNode extends Base<Drivers, Commands> implements ColorSwi
 		return this.drivers.GV1?.value;
 	}
 }
-
+
 NodeFactory.register(ColorSwitchNode);
-
+
 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);
+		return ['186'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is ColorSwitchNode {
-		return ["186"].includes(node.nodeDefId);
+		return ['186'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new ColorSwitchNode(isy, nodeInfo);

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

@@ -17,7 +17,7 @@ const nodeDefId = "119";
 type Commands = DimmerSwitch.Commands;
 type Drivers = DimmerSwitch.Drivers;
 
-export class DimmerSwitchNode extends Base<Drivers, Commands> implements DimmerSwitch.Interface {
+class DimmerSwitchNode extends Base<Drivers, Commands> implements DimmerSwitch.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -34,12 +34,12 @@ export class DimmerSwitchNode extends Base<Drivers, Commands> implements DimmerS
 		WDU: this.writeChanges
 	};
 	static override nodeDefId = "119";
-	static override implements = ["119"];
-	declare readonly nodeDefId: "119";
+	static override implements = ['119'];
+	declare readonly nodeDefId: '119';
 	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.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on(value?: number | ZWave.PercentOpt, rampRate?: number) { return this.sendCommand("DON", value, { RR: rampRate }); }
 	async off() { return this.sendCommand("DOF"); }
@@ -66,13 +66,12 @@ NodeFactory.register(DimmerSwitchNode);
 
 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);
+		return ['119'].includes(node.nodeDefId);
 	}
 	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is DimmerSwitchNode {
-		return ["119"].includes(node.nodeDefId);
+		return ['119'].includes(node.nodeDefId);
 	}
 	export function create(isy: ISY, nodeInfo: NodeInfo) {
 		return new DimmerSwitchNode(isy, nodeInfo);

package/src/Devices/ZigBee/ZigBeeBase.ts

@@ -0,0 +1,22 @@
+import { Family, Insteon } from '../../Definitions/Global/Families.js';
+import { ISY } from '../../ISY.js';
+import { byteToDegree, byteToPct, pctToByte } from '../../Utils.js';
+import { NodeInfo } from '../../Model/NodeInfo.js';
+import { ISYDeviceNode } from '../ISYDeviceNode.js';
+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 ZigBeeBaseDevice<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()
+	{
+		return this.isy.sendRequest(`zmatter/zb/node/${this.address}/def/get?full=true`)
+	}
+
+
+	
+}

package/src/Devices/ZigBee/index.ts

@@ -0,0 +1,13 @@
+import { Family as FamilyEnum } from '../../Definitions/index.js';
+import type { ISY } from '../../ISY.js';
+import { ISYNode } from '../../ISYNode.js';
+import type { NodeInfo } from '../../Model/NodeInfo.js';
+import { NodeFactory } from '../NodeFactory.js';
+
+
+export { ZigBeeBaseDevice as Base } from './ZigBeeBase.js';
+
+
+
+
+//export * from './Generated/index.js';