isy-nodejs 1.0.2-alpha.3 → 1.0.2-alpha.6

package/src/Model/ClassDefinition.ts

@@ -72,12 +72,19 @@ function buildNodeClassDefinitions<T extends Family>(nodeDefs: NodeDef[], family
 					if (id.includes(id2)) {
 						node.implements.push(id2, ...node2.implements);
 						node.equivalentTo.push(id2);
+						node2.equivalents.push(id);
+
 					} else {
 						node2.implements.push(id, ...node.implements);
 						node2.equivalentTo.push(id);
+						node.equivalents.push(id2);
 					}
 				} else if (ext) {
 					node.implements.push(id2, ...node2.implements);
+					if(id.includes(id2))
+					{
+						node.extends.push(id2);
+					}
 				}
 
 				// if (Object.keys(d.).length == 0) {
@@ -113,10 +120,19 @@ function buildNodeClassDefinitions<T extends Family>(nodeDefs: NodeDef[], family
 					e = i;
 				}
 			}
-			node.extends = e;
+
 		}
 		map[node.id] = node;
 	}
+	for (const node of Object.values(map).filter((p) => p.implements.length > 0))
+	{
+		for (const i of node.implements)
+		{
+			let superNode = map[i];
+			if(superNode)
+				superNode.implementedBy?.push(node.id);
+		}
+	}
 	return map;
 }
 
@@ -127,11 +143,17 @@ export class NodeClassDefinition<T extends Family> {
 	public drivers: { [x in Driver.Type]?: DriverDefinition } = {};
 	public dynamic: boolean = false;
 	public equivalentTo: string[] = [];
+
+	public equivalents: string[] = [];
+
+
 	public events: { [x: string]: EventDefinition } = {};
-	public extends?: string;
+	public extends?: string[] = [];
 	public family: T;
 	public id: string;
 	public implements: string[] = [];
+
+	public implementedBy: string[] = [];
 	public label: string;
 	public nlsId: string;
 
@@ -262,7 +284,9 @@ export class NodeClassDefinition<T extends Family> {
 			dynamic: this.family in [Family.ZWave, Family.ZigBee],
 			implements: this.implements.length > 0 ? this.implements : undefined,
 			equivalentTo: this.equivalentTo.length > 0 ? this.equivalentTo : undefined,
-			extends: this.extends
+			extends: this.extends.length > 0 ? this.extends : undefined,
+			equivalents: this.equivalents.length > 0 ? this.equivalents : undefined,
+			implementedBy: this.implementedBy.length > 0 ? this.implementedBy : undefined
 		};
 	}
 
@@ -409,7 +433,7 @@ export abstract class NodeMemberDefinition<TId extends string> {
 			var d = {};
 			for (const rangeDef of toArray(e.range)) {
 				if ('subset' in rangeDef) {
-					d[rangeDef.uom] = { uom: rangeDef.uom, indexId: rangeDef.nls, ...this.#parseSubset(e) };
+					d[rangeDef.uom]= { uom: rangeDef.uom, indexId: rangeDef.nls, ...this.#parseSubset(e) };
 				} else {
 					d[rangeDef.uom] = {
 						uom: rangeDef.uom,
@@ -422,8 +446,14 @@ export abstract class NodeMemberDefinition<TId extends string> {
 						returnType: rangeDef.nls ? EnumDefinition.get(this.classDef.family, rangeDef.nls, rangeDef.uom, this.classDef.id)?.name : undefined
 					};
 				}
+				if(rangeDef.uom === UnitOfMeasure.Index)
+				{
+					d[rangeDef.uom].enum = true;
+				}
+
 			}
 			this.dataType = d;
+
 		}
 	}
 

package/src/Model/ClusterMap.ts

@@ -1,16 +1,20 @@
-import { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
 import * as Clusters from '@project-chip/matter.js/cluster';
-import { OnOffLightDevice } from '@project-chip/matter.js/devices/OnOffLightDevice';
-import { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
-import type { MutableEndpoint } from '@project-chip/matter.js/endpoint/type';
+
 import type { Converter } from '../Converters.js';
 import { DriverType } from '../Definitions/Global/Drivers.js';
-import { Devices } from '../Devices/index.js';
-import { Insteon } from '../Devices/Insteon/index.js';
-
+import { Devices, Insteon } from '../Devices/index.js';
+
+import { ClusterBehavior, MutableEndpoint, SupportedBehaviors } from '@matter/main';
+import type { OnOffLightDevice } from '@matter/main/devices';
+import { BridgedDeviceBasicInformationBehavior } from '@matter/node/behaviors';
+import type { DeviceTypeDefinition } from '@project-chip/matter.js/device';
+import { Family } from '../Definitions/index.js';
+import { NodeFactory } from '../Devices/NodeFactory.js';
 import { CommandsOf, DriversOf, ISYNode } from '../ISYNode.js';
+import { ISYBridgedDeviceBehavior } from '../Matter/Behaviors/ISYBridgedDeviceBehavior.js';
+import { ISYOnOffBehavior } from '../Matter/Behaviors/Insteon/ISYOnOffBehavior.js';
+import type { PickOfType, Remove } from '../Utils.js';
 import { ClusterType } from './ClusterType.js';
-import type { Family } from '../Definitions/index.js';
 
 // #region Type aliases (16)
 
@@ -84,15 +88,12 @@ export type CommandMapping<B, D> =
 //     behavior?: typeof ClusterBehavior;
 
 // }
-export type DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D extends { behaviors: SupportedBehaviors; deviceType: string }> =
-	D extends { behaviors: SupportedBehaviors; deviceType: string } ?
-		{
-			deviceType: D;
-			mapping: EndpointMapping<D, T>;
-		}
-	:	never;
-export type EndpointMapping<A extends { behaviors: any }, D extends ISYNode<Family, any, any, any>> = {
-	[K in Capitalize<StringKeys<A['behaviors']>>]?: BehaviorMapping<A['behaviors'][Uncapitalize<K>], D>; //{
+export type DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D extends MutableEndpoint> = {
+	deviceType: D;
+	mapping: EndpointMapping<D, T>;
+};
+export type EndpointMapping<A extends MutableEndpoint, D extends ISYNode<Family, any, any, any>> = {
+	[K in StringKeys<PickOfType<A['behaviors'], ClusterBehavior>> as Capitalize<K>]?: A['behaviors'][K] extends ClusterBehavior ? BehaviorMapping<A['behaviors'][K], D> : undefined; //{
 	/*attributes?: AttributeMapping<A['behaviors'][Uncapitalize<K>], D>;
 		commands?: CommandMapping<A['behaviors'][Uncapitalize<K>], D>;*/
 	//};
@@ -115,8 +116,9 @@ export type EndpointMapping1<A extends MutableEndpoint, K> = {
 	attributes?: SBAttributeMapping<A['behaviors'], K>;
 	commands?: SBCommandMapping<A['behaviors'], K>;
 };
+//@ts-ignore
 export type FamilyToClusterMap<T extends Family.Insteon | Family.ZWave | Family.ZigBee> = { Family: T } & {
-	[Type in keyof Devices.Insteon]?: DeviceToClusterMap<InstanceType<Devices.Insteon[Type]>, any>;
+	[Type in Extract<keyof Devices.Insteon, `${string}Node`> as Remove<Type, 'Node'>]?: DeviceToClusterMap<InstanceType<Devices.Insteon[Type]>, MutableEndpoint>;
 };
 export type SBAttributeMapping<SB extends SupportedBehaviors, D> = {
 	[K in keyof SB]: Partial<Record<any, DriversOf<D> | { driver: DriversOf<D>; converter?: string }>>;
@@ -139,32 +141,43 @@ export type parameterMapping = {
 export class MappingRegistry {
 	// #region Properties (1)
 
-	public static map: Map<Family,Map<string, DeviceToClusterMap<any, any>>> = new Map();
+	public static map: Map<Family, Map<string, DeviceToClusterMap<ISYNode, MutableEndpoint>>> = new Map();
+
+	public static cache: { [x: string]: DeviceToClusterMap<ISYNode, MutableEndpoint> } = {};
 
 	// #endregion Properties (1)
 
 	// #region Public Static Methods (3)
 
-	public static getMapping<T extends ISYNode<any,any,any,any>>(device: ISYNode<any,any,any,any>) {
-		if(MappingRegistry.map.has(device.family))
-		{
-			let g = MappingRegistry.map.get(device.family);
-			if(g.has(device.constructor.name))
-			{
-				return g.get(device.constructor.name);
-			}
-			else if(g.has(device.nodeDefId))
-			{
-				return g.get(device.nodeDefId);
-			}
-			else if(g.has(device.type))
-			{
-				return g.get(device.type);
+	public static getMapping<T extends ISYNode<any, any, any, any>>(device: T): DeviceToClusterMap<T, MutableEndpoint> {
+		let m = this.cache[device.address];
+		if (!m) {
+			if (MappingRegistry.map.has(device.family)) {
+				let g = MappingRegistry.map.get(device.family);
+				//let m: DeviceToClusterMap<T,MutableEndpoint>;
+				if (g.has(device.constructor.name)) {
+					m = g.get(device.constructor.name);
+				} else if (g.has(device.nodeDefId)) {
+					m = g.get(device.nodeDefId);
+				} else if (g.has(device.type)) {
+					m = g.get(device.type);
+				}
+				if (!m) {
+					for (var nodeDefId of NodeFactory.getImplements(device)) {
+						if (g.has(nodeDefId)) {
+							device.logger(`Mapping found to ${Family[device.family]}.${nodeDefId}`, 'info');
+							m = g.get(nodeDefId);
+							g.set(device.nodeDefId, m);
+
+							break;
+						}
+					}
+				}
+				if (m !== null) this.cache[device.address] = m;
 			}
-
 		}
-		return null;
 
+		return m;
 	}
 
 	public static getMappingForBehavior<T extends ISYNode<any, any, any, any>, B extends ClusterBehavior>(device: T, behavior: B): BehaviorMapping<B, T> {
@@ -176,40 +189,43 @@ export class MappingRegistry {
 		}
 	}
 	//@ts-ignore
-	public static register(map: Partial<FamilyToClusterMap<any>> | {[x in Paths<typeof Devices>]: DeviceToClusterMap<any,any>}) {
-		if("Family" in map)
-		{
-			let regMap : Map<string, DeviceToClusterMap<any, any>>;
-			if(!MappingRegistry.map.has(map.Family))
-			{
+	public static register(map: Partial<FamilyToClusterMap<any>> | { [x in Paths<typeof Devices>]: DeviceToClusterMap<any, any> }) {
+		if ('Family' in map) {
+			let regMap: Map<string, DeviceToClusterMap<any, any>>;
+			if (!MappingRegistry.map.has(map.Family)) {
 				MappingRegistry.map.set(map.Family, new Map());
 			}
+
 			regMap = MappingRegistry.map.get(map.Family);
 			for (var key in map) {
 				if (key !== 'Family') {
-					regMap.set(key, map[key]);
-					regMap.set(Insteon[key]?.name, map[key]); //TODO: This is a hack to allow for the Insteon devices to be registered by name
+					let m = map[key] as DeviceToClusterMap<ISYNode, MutableEndpoint>;
+
+					m = { deviceType: m.deviceType.with(BridgedDeviceBasicInformationBehavior, ISYBridgedDeviceBehavior), mapping: m.mapping };
+					regMap.set(key, m);
+					regMap.set(Insteon[key]?.name, m);
+					regMap.set(Insteon[key].nodeDefId, m);
+
+					//TODO: This is a hack to allow for the Insteon devices to be registered by name
 				}
 			}
-		}
-		else
-		{
-			let regMap : Map<string, DeviceToClusterMap<any, any>>;
+		} else {
+			let regMap: Map<string, DeviceToClusterMap<any, any>>;
 			for (var key in map) {
-				const keys = key.split(".");
+				const keys = key.split('.');
 				let x = Devices[keys[0]][keys[1]] as typeof ISYNode<any, any, any, any>;
-				if(!MappingRegistry.map.has(x.family))
-				{
+				if (!MappingRegistry.map.has(x.family)) {
 					MappingRegistry.map.set(x.family, new Map());
 				}
-			//{family, key} = key.split(".")[0]
-
-			regMap = MappingRegistry.map.get(x.family);
+				//{family, key} = key.split(".")[0]
 
-			regMap.set(keys[1],map[key]);
-			regMap.set(x.name, map[key]);
+				regMap = MappingRegistry.map.get(x.family);
+				let m = map[key] as DeviceToClusterMap<ISYNode, MutableEndpoint>;
+				m = { deviceType: m.deviceType.with(BridgedDeviceBasicInformationBehavior, ISYBridgedDeviceBehavior), mapping: m.mapping };
 
-		}
+				regMap.set(keys[1], m);
+				regMap.set(x.name, m);
+			}
 		}
 	}
 

package/src/Model/NodeInfo.ts

@@ -131,7 +131,7 @@ export function family<F extends Family>(nodeInfo: NodeInfo<any>): nodeInfo is N
 }
 
 export function isDynamic(nodeInfo: NodeInfo<any>): nodeInfo is DynamicNodeInfo {
-	return nodeInfo.family in [Family.ZWave, Family.ZigBee];
+	return [Family.ZWave, Family.ZigBee].includes(nodeInfo.family);
 }
 
 export function isStatic(nodeInfo: NodeInfo<any>): nodeInfo is StaticNodeInfo {

package/src/Utils.ts

@@ -20,10 +20,48 @@ export type PickOfType<T, U> = { [K in keyof T]: T[K] extends U ? (any extends T
 
 export type Paths<T> = T extends object ? { [K in keyof T]: `${Exclude<K, symbol>}${'' | `.${Paths<T[K]>}`}` }[keyof T] : never;
 
+export type Prev = [never, 0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+
+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;
+
+type p = Prev[10];
+export type Join<K, P> =
+	K extends string | number ?
+		P extends string | number ?
+			`${K}${'' extends P ? '' : '.'}${P}`
+		:	never
+	:	never;
+export type PathsWithLimit<T, D extends number = 10> =
+	[D] extends [never] ? never
+	: T extends object ? { [K in keyof T]-?: K extends string | number ? `${K}` | Join<K, PathsWithLimit<T[K], Prev[D]>> : never }[keyof T]
+	: '';
+
+export type Leaves<T, D extends number = 10> =
+	[D] extends [never] ? never
+	: T extends object ? { [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>> }[keyof T]
+	: '';
+
 export function getEnumValueByEnumKey<E extends { [index: string]: number }, T extends keyof E>(enumType: E, enumKey: T): E[T] {
 	return enumType[enumKey];
 }
 
+export type Replace<K extends string, T extends string, U extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${U}${R}` : K;
+
+export type Remove<K extends string, T extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${R}` : K;
+
+export type ReplaceAll<K extends string, T extends string, U extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${U}${ReplaceAll<R, T, U>}` : K;
+
+
 export function getEnumKeyByEnumValue<E extends { [index: string]: number }, T extends E[keyof E]>(enumType: E, enumValue: E[T]): T {
 	return Object.keys(enumType).find((key) => enumType[key] === enumValue) as unknown as T;
 }

package/tsconfig.json

@@ -27,6 +27,12 @@
 		"src/Definitions/Global/*.ts",
 	],
 	"exclude": [
-		"src/Devices/*/Generated/*",
+		
+		"src/Devices/ZigBeeLegacy/Generated/*",
+		"src/Devices/Poly/Generated/*",
+		"src/Devices/Brultech/Generated/*",
+
+		"src/Devices/NCD/Generated/*",
+		"src/Devices/Scene/Generated/*",
 	]
 }

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

@@ -1,123 +0,0 @@
-/* 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";
-import type { ISY } from "../../../ISY.js";
-import type { ISYNode } from "../../../ISYNode.js";
-import { Base } from "../index.js";
-import { ISYDeviceNode } from "../../ISYDeviceNode.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";
-
-export const nodeDefId = "AlertModuleSiren_ADV";
-
-type Commands = AlertModuleSirenAdv.Commands;
-type Drivers = AlertModuleSirenAdv.Drivers;
-
-export class AlertModuleSirenAdvNode extends Base<Drivers, Commands> implements AlertModuleSirenAdv.Interface {
-	public readonly commands = {
-		DON: this.on,
-		DOF: this.off,
-		DFOF: this.fastOff,
-		DFON: this.fastOn,
-		QUERY: this.query,
-		BEEP: this.beep,
-		WDU: this.writeChanges
-	};
-	static nodeDefId = "AlertModuleSiren_ADV";
-	declare readonly nodeDefId: "AlertModuleSiren_ADV";
-	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" });
-	}
-	async on(onLevel?: number) {
-		return this.sendCommand("DON", { OL: onLevel });
-	}
-	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: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
-	public get status(): Insteon.OnLevelRelay {
-		return this.drivers.ST?.value;
-	}
-	public get responding(): Insteon.Error {
-		return this.drivers.ERR?.value;
-	}
-}
-
-NodeFactory.register(AlertModuleSirenAdvNode);
-
-export namespace AlertModuleSirenAdv {
-	export interface Interface extends Omit<InstanceType<typeof AlertModuleSirenAdvNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "AlertModuleSiren_ADV";
-	}
-	export function is(node: ISYNode<any, any, any, any>): node is AlertModuleSirenAdvNode {
-		return node.nodeDefId === nodeDefId;
-	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new AlertModuleSirenAdvNode(isy, nodeInfo);
-	}
-	export const Node = AlertModuleSirenAdvNode;
-	export type Commands = {
-		DON: ((OL?: number) => 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";
-		};
-		WDU: (() => Promise<boolean>) & {
-			label: "Write Changes";
-			name: "writeChanges";
-		};
-	};
-	export type Drivers = {
-		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: Insteon.OnLevelRelay;
-			label: "Status";
-			name: "status";
-		};
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: "Responding";
-			name: "responding";
-		};
-	};
-}

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

@@ -1,123 +0,0 @@
-/* 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";
-import type { ISY } from "../../../ISY.js";
-import type { ISYNode } from "../../../ISYNode.js";
-import { Base } from "../index.js";
-import { ISYDeviceNode } from "../../ISYDeviceNode.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";
-
-export const nodeDefId = "BallastRelayLampSwitch_ADV";
-
-type Commands = BallastRelayLampSwitchAdv.Commands;
-type Drivers = BallastRelayLampSwitchAdv.Drivers;
-
-export class BallastRelayLampSwitchAdvNode extends Base<Drivers, Commands> implements BallastRelayLampSwitchAdv.Interface {
-	public readonly commands = {
-		DON: this.on,
-		DOF: this.off,
-		DFOF: this.fastOff,
-		DFON: this.fastOn,
-		QUERY: this.query,
-		BEEP: this.beep,
-		WDU: this.writeChanges
-	};
-	static nodeDefId = "BallastRelayLampSwitch_ADV";
-	declare readonly nodeDefId: "BallastRelayLampSwitch_ADV";
-	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" });
-	}
-	async on(value?: (0 | 100)) {
-		return this.sendCommand("DON", { value: value });
-	}
-	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: value });
-	}
-	async writeChanges() {
-		return this.sendCommand("WDU");
-	}
-	public get status(): Insteon.Sml {
-		return this.drivers.ST?.value;
-	}
-	public get responding(): Insteon.Error {
-		return this.drivers.ERR?.value;
-	}
-}
-
-NodeFactory.register(BallastRelayLampSwitchAdvNode);
-
-export namespace BallastRelayLampSwitchAdv {
-	export interface Interface extends Omit<InstanceType<typeof BallastRelayLampSwitchAdvNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: "BallastRelayLampSwitch_ADV";
-	}
-	export function is(node: ISYNode<any, any, any, any>): node is BallastRelayLampSwitchAdvNode {
-		return node.nodeDefId === nodeDefId;
-	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new BallastRelayLampSwitchAdvNode(isy, nodeInfo);
-	}
-	export const Node = BallastRelayLampSwitchAdvNode;
-	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";
-		};
-		WDU: (() => Promise<boolean>) & {
-			label: "Write Changes";
-			name: "writeChanges";
-		};
-	};
-	export type Drivers = {
-		ST: {
-			uom: UnitOfMeasure.Percent;
-			value: Insteon.Sml;
-			label: "Status";
-			name: "status";
-		};
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: "Responding";
-			name: "responding";
-		};
-	};
-}