isy-nodejs 1.0.8-alpha.0 → 1.3.24

package/src/Devices/Insteon/Generated/RelayLampSwitchLed.ts

@@ -1,23 +1,20 @@
 /* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
 
-import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
-import { Family } from "../../../Definitions/Global/Families.js";
+import { Family, UnitOfMeasure } from "../../../Definitions/Global/index.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
 import { ISY } from "../../../ISY.js";
-import type { ISYNode } from "../../../ISYNode.js";
-import { Base } from "../index.js";
+import { ISYNode } from "../../../ISYNode.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
+import { Base } from "../index.js";
 import { Driver } from "../../../Definitions/Global/Drivers.js";
 import { Insteon } from "../../../Definitions/index.js";
-import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-const nodeDefId = "RelayLampSwitchLED";
-
-type Commands = RelayLampSwitchLed.Commands;
-type Drivers = RelayLampSwitchLed.Drivers;
+type Commands = RelayLampSwitchLed.Commands.Type;
+type Drivers = RelayLampSwitchLed.Drivers.Type;
+type Events = RelayLampSwitchLed.Events.Type;
 
-class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements RelayLampSwitchLed.Interface {
+export class RelayLampSwitchLed extends Base<Drivers, Commands, Events> implements RelayLampSwitchLed.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
@@ -32,19 +29,19 @@ class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements RelayLam
 	static override nodeDefId = "RelayLampSwitchLED";
 	static override implements = ['RelayLampSwitchLED', "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly", "RelaySwitchOnly_ADV", "RelayLampOnly", "RelayLampOnly_ADV", "IRLincTx", "EZRAIN_Output", "EZIO2x4_Output", "EZIO2x4_Input", "EZIO2x4_Input_ADV", "DoorLock", "BinaryAlarm", "BinaryAlarm_ADV", "BinaryControl", "BinaryControl_ADV", "AlertModuleArmed", "SirenAlert", "SirenArm", "PIR2844OnOff", "PIR2844OnOff_ADV"];
 	declare readonly nodeDefId: 'RelayLampSwitchLED' | "RelayLampSwitchLED_ADV";
-	constructor (isy: ISY, nodeInfo: NodeInfo) {
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.Insteon>) {
 		super(isy, nodeInfo);
 		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 on(value?: (0 | 100)) { return this.sendCommand("DON", [value, UnitOfMeasure.Percent]); }
 	async off() { return this.sendCommand("DOF"); }
 	async fastOff() { return this.sendCommand("DFOF"); }
 	async fastOn() { return this.sendCommand("DFON"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", value); }
-	async led(value: Insteon.I3RgbLed) { return this.sendCommand("LED", value); }
-	async backlight(value: number) { return this.sendCommand("BL", value); }
+	async beep(value?: number) { return this.sendCommand("BEEP", [value, UnitOfMeasure.LevelFrom0To255]); }
+	async led(value: Insteon.I3RgbLed) { return this.sendCommand("LED", [value, UnitOfMeasure.Index]); }
+	async backlight(value: number) { return this.sendCommand("BL", [value, UnitOfMeasure.Percent]); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get status(): Insteon.OnLevelRelay {
 		return this.drivers.ST?.value;
@@ -54,72 +51,133 @@ class RelayLampSwitchLedNode extends Base<Drivers, Commands> implements RelayLam
 	}
 }
 
-NodeFactory.register(RelayLampSwitchLedNode);
-NodeFactory.register(RelayLampSwitchLedNode, "RelayLampSwitchLED_ADV");
+NodeFactory.register(RelayLampSwitchLed);
+NodeFactory.register(RelayLampSwitchLed, "RelayLampSwitchLED_ADV");
 
 export namespace RelayLampSwitchLed {
-	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchLedNode>, keyof ISYDeviceNode<any, any, any, any>> {
+	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchLed>, keyof ISYDeviceNode<any, any, any, any>> {
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchLedNode {
+	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchLed {
 		return ['RelayLampSwitchLED', "RelayLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}
-	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayLampSwitchLedNode {
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayLampSwitchLed {
 		return ['RelayLampSwitchLED', "RelayLampSwitchLED_ADV"].includes(node.nodeDefId);
 	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new RelayLampSwitchLedNode(isy, nodeInfo);
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.Insteon>) {
+		return new RelayLampSwitchLed(isy, nodeInfo);
 	}
-	export const Node = RelayLampSwitchLedNode;
-	export type Commands = {
-		DON: ((value?: (0 | 100)) => Promise<boolean>) & {
-			label: "On";
-			name: "on";
-		};
-		DOF: (() => Promise<boolean>) & {
-			label: "Off";
-			name: "off";
-		};
-		DFOF: (() => Promise<boolean>) & {
-			label: "Fast Off";
-			name: "fastOff";
-		};
-		DFON: (() => Promise<boolean>) & {
-			label: "Fast On";
-			name: "fastOn";
-		};
-		QUERY: (() => Promise<boolean>) & {
-			label: "Query";
-			name: "query";
-		};
-		BEEP: ((value?: number) => Promise<boolean>) & {
-			label: "Beep";
-			name: "beep";
-		};
-		LED: ((value: Insteon.I3RgbLed) => Promise<boolean>) & {
-			label: "LED";
-			name: "led";
-		};
-		BL: ((value: number) => Promise<boolean>) & {
-			label: "Backlight";
-			name: "backlight";
+	export const Node = RelayLampSwitchLed;
+	export const Class = RelayLampSwitchLed;
+	export namespace Commands {
+		export type Type = {
+			DON: ((value?: (0 | 100)) => Promise<boolean>) & {
+				label: "On";
+				name: "on";
+			};
+			DOF: (() => Promise<boolean>) & {
+				label: "Off";
+				name: "off";
+			};
+			DFOF: (() => Promise<boolean>) & {
+				label: "Fast Off";
+				name: "fastOff";
+			};
+			DFON: (() => Promise<boolean>) & {
+				label: "Fast On";
+				name: "fastOn";
+			};
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+			BEEP: ((value?: number) => Promise<boolean>) & {
+				label: "Beep";
+				name: "beep";
+			};
+			LED: ((value: Insteon.I3RgbLed) => Promise<boolean>) & {
+				label: "LED";
+				name: "led";
+			};
+			BL: ((value: number) => Promise<boolean>) & {
+				label: "Backlight";
+				name: "backlight";
+			};
+			WDU: (() => Promise<boolean>) & {
+				label: "Write Changes";
+				name: "writeChanges";
+			};
 		};
-		WDU: (() => Promise<boolean>) & {
-			label: "Write Changes";
-			name: "writeChanges";
-		};
-	};
-	export type Drivers = {
-		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay;
-			label: "Status";
-			name: "status";
+	}
+	export enum Commands {
+		on = 'DON',
+		off = 'DOF',
+		fastOff = 'DFOF',
+		fastOn = 'DFON',
+		query = 'QUERY',
+		beep = 'BEEP',
+		led = 'LED',
+		backlight = 'BL',
+		writeChanges = 'WDU'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ST: {
+				uom: UnitOfMeasure.Percent;
+				value: Insteon.OnLevelRelay;
+				label: "Status";
+				name: "status";
+			};
+			ERR: {
+				uom: UnitOfMeasure.Index;
+				value: Insteon.Error;
+				label: "Responding";
+				name: "responding";
+			};
 		};
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: "Responding";
-			name: "responding";
+	}
+	export enum Drivers {
+		status = 'ST',
+		responding = 'ERR'
+	}
+	export namespace Events {
+		export type Type = {
+			DON: {
+				label: "On";
+				name: "on";
+			};
+			DOF: {
+				label: "Off";
+				name: "off";
+			};
+			DFOF: {
+				label: "Fast Off";
+				name: "fastOff";
+			};
+			DFON: {
+				label: "Fast On";
+				name: "fastOn";
+			};
+			FDUP: {
+				label: "Fade Up";
+				name: "fadeUp";
+			};
+			FDDOWN: {
+				label: "Fade Down";
+				name: "fadeDown";
+			};
+			FDSTOP: {
+				label: "Fade Stop";
+				name: "fadeStop";
+			};
 		};
-	};
+	}
+	export enum Events {
+		on = 'DON',
+		off = 'DOF',
+		fastOff = 'DFOF',
+		fastOn = 'DFON',
+		fadeUp = 'FDUP',
+		fadeDown = 'FDDOWN',
+		fadeStop = 'FDSTOP'
+	}
 }

package/src/Devices/Insteon/Generated/RelaySwitch.ts

@@ -1,23 +1,20 @@
 /* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
 
-import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
-import { Family } from "../../../Definitions/Global/Families.js";
+import { Family, UnitOfMeasure } from "../../../Definitions/Global/index.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
 import { ISY } from "../../../ISY.js";
-import type { ISYNode } from "../../../ISYNode.js";
-import { Base } from "../index.js";
+import { ISYNode } from "../../../ISYNode.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
+import { Base } from "../index.js";
 import { Driver } from "../../../Definitions/Global/Drivers.js";
 import { Insteon } from "../../../Definitions/index.js";
-import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-const nodeDefId = "RelaySwitchOnly";
-
-type Commands = RelaySwitch.Commands;
-type Drivers = RelaySwitch.Drivers;
+type Commands = RelaySwitch.Commands.Type;
+type Drivers = RelaySwitch.Drivers.Type;
+type Events = RelaySwitch.Events.Type;
 
-class RelaySwitchNode extends Base<Drivers, Commands> implements RelaySwitch.Interface {
+export class RelaySwitch extends Base<Drivers, Commands, Events> implements RelaySwitch.Interface {
 	public override readonly commands = {
 		BEEP: this.beep,
 		BL: this.backlight,
@@ -26,54 +23,108 @@ class RelaySwitchNode extends Base<Drivers, Commands> implements RelaySwitch.Int
 	static override nodeDefId = "RelaySwitchOnly";
 	static override implements = ['RelaySwitchOnly', "IRLincTx", "SirenAlert", "SirenArm"];
 	declare readonly nodeDefId: 'RelaySwitchOnly' | "RelaySwitchOnly_ADV";
-	constructor (isy: ISY, nodeInfo: NodeInfo) {
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.Insteon>) {
 		super(isy, nodeInfo);
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
-	async beep(value?: number) { return this.sendCommand("BEEP", value); }
-	async backlight(value: number) { return this.sendCommand("BL", value); }
+	async beep(value?: number) { return this.sendCommand("BEEP", [value, UnitOfMeasure.LevelFrom0To255]); }
+	async backlight(value: number) { return this.sendCommand("BL", [value, UnitOfMeasure.Percent]); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
 	}
 }
 
-NodeFactory.register(RelaySwitchNode);
-NodeFactory.register(RelaySwitchNode, "RelaySwitchOnly_ADV");
+NodeFactory.register(RelaySwitch);
+NodeFactory.register(RelaySwitch, "RelaySwitchOnly_ADV");
 
 export namespace RelaySwitch {
-	export interface Interface extends Omit<InstanceType<typeof RelaySwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
+	export interface Interface extends Omit<InstanceType<typeof RelaySwitch>, keyof ISYDeviceNode<any, any, any, any>> {
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitchNode {
+	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitch {
 		return ['RelaySwitchOnly', "RelaySwitchOnly_ADV"].includes(node.nodeDefId);
 	}
-	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelaySwitchNode {
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelaySwitch {
 		return ['RelaySwitchOnly', "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "KeypadDimmer", "KeypadDimmer_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelaySwitchOnlyPlusQuery", "RelaySwitchOnlyPlusQuery_ADV", "RelaySwitchOnly_ADV"].includes(node.nodeDefId);
 	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new RelaySwitchNode(isy, nodeInfo);
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.Insteon>) {
+		return new RelaySwitch(isy, nodeInfo);
 	}
-	export const Node = RelaySwitchNode;
-	export type Commands = {
-		BEEP: ((value?: number) => Promise<boolean>) & {
-			label: "Beep";
-			name: "beep";
+	export const Node = RelaySwitch;
+	export const Class = RelaySwitch;
+	export namespace Commands {
+		export type Type = {
+			BEEP: ((value?: number) => Promise<boolean>) & {
+				label: "Beep";
+				name: "beep";
+			};
+			BL: ((value: number) => Promise<boolean>) & {
+				label: "Backlight";
+				name: "backlight";
+			};
+			WDU: (() => Promise<boolean>) & {
+				label: "Write Changes";
+				name: "writeChanges";
+			};
 		};
-		BL: ((value: number) => Promise<boolean>) & {
-			label: "Backlight";
-			name: "backlight";
-		};
-		WDU: (() => Promise<boolean>) & {
-			label: "Write Changes";
-			name: "writeChanges";
+	}
+	export enum Commands {
+		beep = 'BEEP',
+		backlight = 'BL',
+		writeChanges = 'WDU'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ERR: {
+				uom: UnitOfMeasure.Index;
+				value: Insteon.Error;
+				label: "Responding";
+				name: "responding";
+			};
 		};
-	};
-	export type Drivers = {
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: "Responding";
-			name: "responding";
+	}
+	export enum Drivers {
+		responding = 'ERR'
+	}
+	export namespace Events {
+		export type Type = {
+			DON: {
+				label: "On";
+				name: "on";
+			};
+			DOF: {
+				label: "Off";
+				name: "off";
+			};
+			DFOF: {
+				label: "Fast Off";
+				name: "fastOff";
+			};
+			DFON: {
+				label: "Fast On";
+				name: "fastOn";
+			};
+			FDUP: {
+				label: "Fade Up";
+				name: "fadeUp";
+			};
+			FDDOWN: {
+				label: "Fade Down";
+				name: "fadeDown";
+			};
+			FDSTOP: {
+				label: "Fade Stop";
+				name: "fadeStop";
+			};
 		};
-	};
+	}
+	export enum Events {
+		on = 'DON',
+		off = 'DOF',
+		fastOff = 'DFOF',
+		fastOn = 'DFON',
+		fadeUp = 'FDUP',
+		fadeDown = 'FDDOWN',
+		fadeStop = 'FDSTOP'
+	}
 }

package/src/Devices/Insteon/Generated/RelaySwitchOnlyPlusQuery.ts

@@ -1,23 +1,20 @@
 /* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
 
-import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
-import { Family } from "../../../Definitions/Global/Families.js";
+import { Family, UnitOfMeasure } from "../../../Definitions/Global/index.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
 import { ISY } from "../../../ISY.js";
-import type { ISYNode } from "../../../ISYNode.js";
-import { Base } from "../index.js";
+import { ISYNode } from "../../../ISYNode.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
+import { Base } from "../index.js";
 import { Driver } from "../../../Definitions/Global/Drivers.js";
 import { Insteon } from "../../../Definitions/index.js";
-import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-const nodeDefId = "RelaySwitchOnlyPlusQuery";
+type Commands = RelaySwitchOnlyPlusQuery.Commands.Type;
+type Drivers = RelaySwitchOnlyPlusQuery.Drivers.Type;
+type Events = RelaySwitchOnlyPlusQuery.Events.Type;
 
-type Commands = RelaySwitchOnlyPlusQuery.Commands;
-type Drivers = RelaySwitchOnlyPlusQuery.Drivers;
-
-class RelaySwitchOnlyPlusQueryNode extends Base<Drivers, Commands> implements RelaySwitchOnlyPlusQuery.Interface {
+export class RelaySwitchOnlyPlusQuery extends Base<Drivers, Commands, Events> implements RelaySwitchOnlyPlusQuery.Interface {
 	public override readonly commands = {
 		QUERY: this.query,
 		BEEP: this.beep,
@@ -27,59 +24,114 @@ class RelaySwitchOnlyPlusQueryNode extends Base<Drivers, Commands> implements Re
 	static override nodeDefId = "RelaySwitchOnlyPlusQuery";
 	static override implements = ['RelaySwitchOnlyPlusQuery', "RelaySwitchOnly", "RelaySwitchOnly_ADV", "IRLincTx", "SirenAlert", "SirenArm"];
 	declare readonly nodeDefId: 'RelaySwitchOnlyPlusQuery' | "RelaySwitchOnlyPlusQuery_ADV";
-	constructor (isy: ISY, nodeInfo: NodeInfo) {
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.Insteon>) {
 		super(isy, nodeInfo);
 		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async query() { return this.sendCommand("QUERY"); }
-	async beep(value?: number) { return this.sendCommand("BEEP", value); }
-	async backlight(value: number) { return this.sendCommand("BL", value); }
+	async beep(value?: number) { return this.sendCommand("BEEP", [value, UnitOfMeasure.LevelFrom0To255]); }
+	async backlight(value: number) { return this.sendCommand("BL", [value, UnitOfMeasure.Percent]); }
 	async writeChanges() { return this.sendCommand("WDU"); }
 	public get responding(): Insteon.Error {
 		return this.drivers.ERR?.value;
 	}
 }
 
-NodeFactory.register(RelaySwitchOnlyPlusQueryNode);
-NodeFactory.register(RelaySwitchOnlyPlusQueryNode, "RelaySwitchOnlyPlusQuery_ADV");
+NodeFactory.register(RelaySwitchOnlyPlusQuery);
+NodeFactory.register(RelaySwitchOnlyPlusQuery, "RelaySwitchOnlyPlusQuery_ADV");
 
 export namespace RelaySwitchOnlyPlusQuery {
-	export interface Interface extends Omit<InstanceType<typeof RelaySwitchOnlyPlusQueryNode>, keyof ISYDeviceNode<any, any, any, any>> {
+	export interface Interface extends Omit<InstanceType<typeof RelaySwitchOnlyPlusQuery>, keyof ISYDeviceNode<any, any, any, any>> {
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitchOnlyPlusQueryNode {
+	export function is(node: ISYNode<any, any, any, any>): node is RelaySwitchOnlyPlusQuery {
 		return ['RelaySwitchOnlyPlusQuery', "RelaySwitchOnlyPlusQuery_ADV"].includes(node.nodeDefId);
 	}
-	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelaySwitchOnlyPlusQueryNode {
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelaySwitchOnlyPlusQuery {
 		return ['RelaySwitchOnlyPlusQuery', "DimmerMotorSwitch", "DimmerMotorSwitch_ADV", "DimmerLampSwitch", "DimmerLampSwitch_ADV", "DimmerLampSwitchLED", "DimmerLampSwitchLED_ADV", "KeypadDimmer", "KeypadDimmer_ADV", "RelayLampSwitch", "RelayLampSwitch_ADV", "RelayLampSwitchLED", "RelayLampSwitchLED_ADV", "RelaySwitchOnlyPlusQuery_ADV"].includes(node.nodeDefId);
 	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new RelaySwitchOnlyPlusQueryNode(isy, nodeInfo);
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.Insteon>) {
+		return new RelaySwitchOnlyPlusQuery(isy, nodeInfo);
 	}
-	export const Node = RelaySwitchOnlyPlusQueryNode;
-	export type Commands = {
-		QUERY: (() => Promise<boolean>) & {
-			label: "Query";
-			name: "query";
-		};
-		BEEP: ((value?: number) => Promise<boolean>) & {
-			label: "Beep";
-			name: "beep";
+	export const Node = RelaySwitchOnlyPlusQuery;
+	export const Class = RelaySwitchOnlyPlusQuery;
+	export namespace Commands {
+		export type Type = {
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+			BEEP: ((value?: number) => Promise<boolean>) & {
+				label: "Beep";
+				name: "beep";
+			};
+			BL: ((value: number) => Promise<boolean>) & {
+				label: "Backlight";
+				name: "backlight";
+			};
+			WDU: (() => Promise<boolean>) & {
+				label: "Write Changes";
+				name: "writeChanges";
+			};
 		};
-		BL: ((value: number) => Promise<boolean>) & {
-			label: "Backlight";
-			name: "backlight";
-		};
-		WDU: (() => Promise<boolean>) & {
-			label: "Write Changes";
-			name: "writeChanges";
+	}
+	export enum Commands {
+		query = 'QUERY',
+		beep = 'BEEP',
+		backlight = 'BL',
+		writeChanges = 'WDU'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ERR: {
+				uom: UnitOfMeasure.Index;
+				value: Insteon.Error;
+				label: "Responding";
+				name: "responding";
+			};
 		};
-	};
-	export type Drivers = {
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: "Responding";
-			name: "responding";
+	}
+	export enum Drivers {
+		responding = 'ERR'
+	}
+	export namespace Events {
+		export type Type = {
+			DON: {
+				label: "On";
+				name: "on";
+			};
+			DOF: {
+				label: "Off";
+				name: "off";
+			};
+			DFOF: {
+				label: "Fast Off";
+				name: "fastOff";
+			};
+			DFON: {
+				label: "Fast On";
+				name: "fastOn";
+			};
+			FDUP: {
+				label: "Fade Up";
+				name: "fadeUp";
+			};
+			FDDOWN: {
+				label: "Fade Down";
+				name: "fadeDown";
+			};
+			FDSTOP: {
+				label: "Fade Stop";
+				name: "fadeStop";
+			};
 		};
-	};
+	}
+	export enum Events {
+		on = 'DON',
+		off = 'DOF',
+		fastOff = 'DFOF',
+		fastOn = 'DFON',
+		fadeUp = 'FDUP',
+		fadeDown = 'FDDOWN',
+		fadeStop = 'FDSTOP'
+	}
 }