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

package/src/Matter/Mappings/MappingRegistry.ts

@@ -1,22 +1,23 @@
+import * as Cluster from '@matter/types/cluster';
 import type * as Clusters from '@matter/types/clusters';
-import * as Cluster from '@matter/types/cluster'
 
-import type { Converter } from '../../Converters.js';
-import { DriverType } from '../../Definitions/Global/Drivers.js';
-import { Devices, Insteon } from '../../Devices/index.js';
-import type {Simplify, SimplifyDeep} from 'type-fest';
 import { ClusterBehavior, MutableEndpoint, SupportedBehaviors } from '@matter/main';
 import { DimmableLightDevice, OnOffLightDevice } from '@matter/main/devices';
 import { BridgedDeviceBasicInformationBehavior } from '@matter/node/behaviors';
 import type { DeviceTypeDefinition } from '@project-chip/matter.js/device';
+import type { Simplify, SimplifyDeep } from 'type-fest';
+import type { Converter } from '../../Converters.js';
+import { DriverType } from '../../Definitions/Global/Drivers.js';
 import { Family } from '../../Definitions/index.js';
 import type { Constructor } from '../../Devices/Constructor.js';
 import { NodeFactory } from '../../Devices/NodeFactory.js';
+import { Devices, Insteon } from '../../Devices/index.js';
 import { CommandsOf, DriversOf, ISYNode } from '../../ISYNode.js';
 import { ClusterType } from '../../Model/ClusterType.js';
 import type { PathsWithLimit, PickOfType, Remove } from '../../Utils.js';
 import { ISYBridgedDeviceBehavior } from '../Behaviors/ISYBridgedDeviceBehavior.js';
-import { ISYOnOffBehavior } from '../Behaviors/Insteon/ISYOnOffBehavior.js';
+import { BehaviorRegistry } from '../Behaviors/BehaviorRegistry.js';
+
 
 // #region Type aliases (16)
 
@@ -27,7 +28,6 @@ export type AttributeMapping<B, D> =
 export type ClusterMapping<B, T extends ISYNode<any, any, any, any>> = {
 	attributes?: ClusterAttributeMapping<B, T>;
 	commands?: ClusterCommandMapping<B, T>;
-
 };
 export type ClusterAttributeMapping<A, K> = {
 	[key in keyof Cluster.ClusterType.AttributesOf<A>]: { driver: Extract<keyof DriversOf<K>, string>; converter?: Converter.KnownConverters } | Extract<keyof DriversOf<K>, string>;
@@ -91,43 +91,33 @@ export type CommandMapping<B, D> =
 //     behavior?: typeof ClusterBehavior;
 
 // }
-export interface DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D extends MutableEndpoint>  {
+export interface DeviceToClusterMap<T extends ISYNode<Family, any, any, any>, D extends MutableEndpoint> {
 	deviceType: D;
 	mapping: EndpointMapping<D, T>;
-};
-
-
-
+}
 
 export interface Mapping<T extends ISYNode, D extends MutableEndpoint> {
 	deviceType: D;
 
 	nodeType?: T;
 	mapping?: {
-		[K in keyof D['behaviors']]?:
-		{attributes?: {
-			[K2 in keyof Cluster.ClusterType.AttributesOf<D['behaviors'][K]>]: { driver: keyof DriversOf<T>; converter?: Converter.KnownConverters } | keyof DriversOf<T>;
-		},
-		commands?: {
-			[K2 in keyof Cluster.ClusterType.CommandsOf<D['behaviors'][K]>]: { command: keyof CommandsOf<T>; converter?: Converter.KnownConverters } | keyof CommandsOf<T>;
-		}
-		}
-	}
-
-
-
+		[K in keyof D['behaviors']]?: {
+			attributes?: {
+				[K2 in keyof Cluster.ClusterType.AttributesOf<D['behaviors'][K]>]: { driver: keyof DriversOf<T>; converter?: Converter.KnownConverters } | keyof DriversOf<T>;
+			};
+			commands?: {
+				[K2 in keyof Cluster.ClusterType.CommandsOf<D['behaviors'][K]>]: { command: keyof CommandsOf<T>; converter?: Converter.KnownConverters } | keyof CommandsOf<T>;
+			};
+		};
+	};
 }
 
-   function addA<T extends ISYNode<any,any,any,any>,D extends MutableEndpoint>(mapping1: Mapping<T,D>, mapping2: Mapping<T,D>) : Mapping<T,D> {
-		return {deviceType: mapping1.deviceType, nodeType: mapping1.nodeType, mapping: {...mapping1.mapping, ...mapping2.mapping}};
-
-	}
-
-
-
+function addA<T extends ISYNode<any, any, any, any>, D extends MutableEndpoint>(mapping1: Mapping<T, D>, mapping2: Mapping<T, D>): Mapping<T, D> {
+	return { deviceType: mapping1.deviceType, nodeType: mapping1.nodeType, mapping: { ...mapping1.mapping, ...mapping2.mapping } };
+}
 
 export type EndpointMapping<A extends MutableEndpoint, D extends ISYNode<Family, any, any, any>> = {
-	[K in StringKeys<A['behaviors']>]?: ClusterMapping<A['behaviors'][K],D> //{
+	[K in StringKeys<A['behaviors']>]?: ClusterMapping<A['behaviors'][K], D>; //{
 	/*attributes?: AttributeMapping<A['behaviors'][Uncapitalize<K>], D>;
 		commands?: CommandMapping<A['behaviors'][Uncapitalize<K>], D>;*/
 	//};
@@ -154,13 +144,10 @@ export type EndpointMapping1<A extends MutableEndpoint, K> = {
 
 type SupportedFamily = Family.Insteon | Family.ZWave | Family.ZigBee;
 export type FamilyToClusterMap<T extends SupportedFamily> = { Family: T } & {
-	[Type in Extract<keyof Devices.Insteon, `${string}Node`> as Remove<Type, 'Node'>]?: DeviceToClusterMap<InstanceType<Devices.Insteon[Type]>, MutableEndpoint>;
+	[Type in keyof Devices.Insteon]?: Devices.Insteon[Type] extends {Node: Constructor<ISYNode<any,any,any,any>>} ?DeviceToClusterMap<InstanceType<Devices.Insteon[Type]["Node"]>, MutableEndpoint> : undefined;
 };
 
-interface ISYtoMatterMapping<N extends ISYNode, M extends MutableEndpoint> extends DeviceToClusterMap<N, M> {
-
-
-}
+interface ISYtoMatterMapping<N extends ISYNode, M extends MutableEndpoint> extends DeviceToClusterMap<N, M> {}
 
 export function add<const F extends SupportedFamily, const T extends ISYNode<F>, const D extends MutableEndpoint>(
 	familyToClusterMap: FamilyToClusterMap<F>,
@@ -275,7 +262,10 @@ export class MappingRegistry {
 
 				regMap = MappingRegistry.map.get(x.family);
 				let m = map[key] as DeviceToClusterMap<ISYNode, MutableEndpoint>;
-				m = { deviceType: m.deviceType.with(BridgedDeviceBasicInformationBehavior, ISYBridgedDeviceBehavior), mapping: m.mapping };
+				let deviceType = m.deviceType;
+				deviceType = deviceType.with(BridgedDeviceBasicInformationBehavior, ISYBridgedDeviceBehavior);
+
+				m = { deviceType: deviceType, mapping: m.mapping };
 
 				regMap.set(keys[1], m);
 				regMap.set(x.name, m);
@@ -299,8 +289,7 @@ var clusterMap = {
 	}
 };
 
-
-interface SimplyEndpointMapping<T extends ISYNode<Family, any, any, any>,K extends MutableEndpoint> extends SimplifyDeep<ISYtoMatterMapping<T,K>> {}
+interface SimplyEndpointMapping<T extends ISYNode<Family, any, any, any>, K extends MutableEndpoint> extends SimplifyDeep<ISYtoMatterMapping<T, K>> {}
 
 /*
 const map = {

package/src/Registry.ts

@@ -0,0 +1,112 @@
+import { Family } from './Definitions/index.js';
+import { nodeDefId } from './Devices/Insteon/KeypadButton.js';
+import { NodeFactory } from './Devices/NodeFactory.js';
+import type { ISYDeviceInfo } from './ISYDevice.js';
+import { ISYNode } from './ISYNode.js';
+import type { StringKeys } from './Utils.js';
+
+export class Registry<K extends keyof any,T> {
+
+	Global: { [x in K]?: T } = {};
+	FamilyLevel: { [x in StringKeys<typeof Family>]?: { [y in K]?: T } } = {};
+
+	DeviceLevel: { [x: string]: { [y in K]?: T } } = {};
+	NodeLevel: { [x: string]: { [y in K]?: T } } = {};
+
+
+	registerGlobal(key: K, value: T): void {
+		this.Global[key] = value;
+	}
+
+	registerFamilyLevel<F extends Family>(family: F & number, key: K, value: T): void {
+		this.FamilyLevel[Family[family] as string] = this.FamilyLevel[Family[family] as string] ?? {};
+		this.FamilyLevel[Family[family] as string]![key] = value;
+	}
+
+	registerDeviceLevel(device: string, key: K, value: T): void {
+		this.DeviceLevel[device] = this.DeviceLevel[device] ?? {};
+		this.DeviceLevel[device]![key] = value;
+	}
+
+	registerNodeLevel(nodeDefId: string, key: K, value: T): void {
+		this.NodeLevel[nodeDefId] = this.NodeLevel[nodeDefId] ?? {};
+		this.NodeLevel[nodeDefId]![key] = value;
+	}
+
+	register(key: K, value: T): void
+	register(key: K, value: T, deviceType: string): void
+	register(key: K, value: T, nodeClass: typeof ISYNode): void
+	register(key: K, value: T, discriminant?: string | typeof ISYNode | Family ): void
+	{
+		if(discriminant === undefined)
+		{
+			this.registerGlobal(key, value);
+			return;
+		}
+		if(typeof discriminant === 'string')
+		{
+			this.registerDeviceLevel(discriminant, key, value);
+			return;
+		}
+		if(discriminant instanceof ISYNode.constructor)
+		{
+			this.registerNodeLevel(discriminant.nodeDefId, key, value);
+			for (const nodeDefId in NodeFactory.getImplements(discriminant))
+			{
+				this.registerNodeLevel(nodeDefId, key, value);
+			}
+			this.registerFamilyLevel(discriminant.family, key, value);
+			return;
+		}
+
+	}
+
+	getGlobal(key: K): T | undefined {
+		return this.Global[key];
+	}
+
+	getFamilyLevel<F extends Family>(family: F & number, key: K): T | undefined {
+		return this.FamilyLevel[Family[family] as string]?.[key];
+	}
+
+	getDeviceLevel(device: string, key: K): T | undefined {
+		return this.DeviceLevel[device]?.[key];
+	}
+
+	getNodeLevel(nodeDefId: string, key: K): T | undefined {
+		 return this.NodeLevel[nodeDefId]?.[key];
+	}
+
+	get(device: ISYDeviceInfo & ISYNode, key: K): T | undefined
+	{
+		if(device.type)
+		{
+			let d = this.getDeviceLevel(device.type, key);
+			if(d)
+				return d;
+		}
+
+			let d = this.getNodeLevel(device.nodeDefId, key);
+			if(d)
+			{
+				return d;
+			}
+			else
+			{
+				for (const nodeDefId in NodeFactory.getImplements(device))
+				{
+					let d = this.getNodeLevel(nodeDefId, key);
+					if(d)
+						return d;
+				}
+			}
+		let f = this.getFamilyLevel(device.family, key);
+		if(f)
+			return f;
+		return this.getGlobal(key);
+
+	}
+
+
+
+}

package/src/Utils.ts

@@ -12,6 +12,35 @@ import { readFile } from 'fs/promises';
 import path from 'path';
 import { Family } from './Definitions/index.js';
 import { EventType } from './Events/EventType.js';
+import type { Constructor } from 'type-fest';
+
+
+export type Factory<T extends object> =
+	{
+		create?: (...args: any[]) => T;
+		is?<K extends T>(obj: object): obj is T;
+		isImplementedBy?(obj: object): obj is T;
+
+
+	} & {Node: Constructor<T>} | {Device: Constructor<T>};
+
+export function isFactory(obj: any): obj is Factory<any> {
+	return obj.Node !== undefined || obj.Device !== undefined;
+}
+
+export function getConstructor<T extends object>(obj: Factory<T> | Constructor<T>): Constructor<T> {
+	if(isFactory(obj)) {
+		if('Node' in obj) {
+			return obj.Node;
+		}
+		return obj.Device;
+	}
+	return obj;
+}
+
+
+export type ConstructorOf<T> = T extends Factory<infer U>  ? Constructor<U> : T extends Constructor<infer U> ? U : Constructor<T> ;
+
 
 export type StringKeys<T> = Extract<keyof T, string>;
 

package/src/Devices/Insteon/DimmerLampSwitch.ts

@@ -1,207 +0,0 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
-import { Driver } from '../../Definitions/Global/Drivers.js';
-import { Family } from '../../Definitions/Global/Families.js';
-import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
-import { Insteon } from '../../Definitions/index.js';
-import type { ISY } from '../../ISY.js';
-import type { ISYNode } from '../../ISYNode.js';
-import type { DriverState } from '../../Model/DriverState.js';
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import { ISYDeviceNode } from '../ISYDeviceNode.js';
-import { NodeFactory } from '../NodeFactory.js';
-import { InsteonBaseDevice as Base } from './InsteonBaseDevice.js';
-
-export const nodeDefId = 'DimmerLampSwitch';
-
-type Commands = DimmerLampSwitch.Commands;
-type Drivers = DimmerLampSwitch.Drivers;
-
-export class DimmerLampSwitchNode extends Base<Drivers, Commands> implements DimmerLampSwitch.Interface {
-	public override readonly commands = {
-		DON: this.on,
-		DOF: this.off,
-		DFOF: this.fastOff,
-		DFON: this.fastOn,
-		BRT: this.brighten,
-		DIM: this.dim,
-		FDUP: this.fadeUp,
-		FDDOWN: this.fadeDown,
-		FDSTOP: this.fadeStop,
-		QUERY: this.query,
-		BEEP: this.beep,
-		OL: this.updateOnLevel,
-		RR: this.updateRampRate,
-		BL: this.backlight,
-		WDU: this.writeChanges
-	};
-	static override nodeDefId = 'DimmerLampSwitch';
-	declare readonly nodeDefId: 'DimmerLampSwitch';
-	constructor(isy: ISY, nodeInfo: NodeInfo) {
-		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create('ST', this, nodeInfo.state['ST'], { uom: UnitOfMeasure.LevelFrom0To255, label: 'Status', name: 'status' });
-		this.drivers.OL = Driver.create('OL', this, nodeInfo.state['OL'] as DriverState, { uom: UnitOfMeasure.Percent, label: 'On Level', name: 'onLevel' });
-		this.drivers.RR = Driver.create('RR', this, nodeInfo.state['RR'] as DriverState, { uom: UnitOfMeasure.Index, label: 'Ramp Rate', name: 'rampRate' });
-		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.state['ERR'] as DriverState, { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
-	}
-	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');
-	}
-	async brighten() {
-		return this.sendCommand('BRT');
-	}
-	async dim() {
-		return this.sendCommand('DIM');
-	}
-	async fadeUp() {
-		return this.sendCommand('FDUP');
-	}
-	async fadeDown() {
-		return this.sendCommand('FDDOWN');
-	}
-	async fadeStop() {
-		return this.sendCommand('FDSTOP');
-	}
-	async query() {
-		return this.sendCommand('QUERY');
-	}
-	async beep(value?: number) {
-		return this.sendCommand('BEEP', { value: value });
-	}
-	async updateOnLevel(value: number) {
-		return this.sendCommand('OL', { value: value });
-	}
-	async updateRampRate(value: number) {
-		return this.sendCommand('RR', { value: value });
-	}
-	async backlight(value: number) {
-		return this.sendCommand('BL', { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand('WDU');
-	}
-	public get status(): number {
-		return this.drivers.ST?.value;
-	}
-	public get onLevel(): number {
-		return this.drivers.OL?.value;
-	}
-	public get rampRate(): number {
-		return this.drivers.RR?.value;
-	}
-	public get responding(): Insteon.Error {
-		return this.drivers.ERR?.value;
-	}
-}
-
-NodeFactory.register(DimmerLampSwitchNode);
-
-export namespace DimmerLampSwitch {
-	export interface Interface extends Omit<InstanceType<typeof DimmerLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: 'DimmerLampSwitch';
-	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode {
-		return node.nodeDefId === nodeDefId;
-	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new DimmerLampSwitchNode(isy, nodeInfo);
-	}
-	export const Node = DimmerLampSwitchNode;
-	export type Commands = {
-		DON: ((value?: 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';
-		};
-		BRT: (() => Promise<boolean>) & {
-			label: 'Brighten';
-			name: 'brighten';
-		};
-		DIM: (() => Promise<boolean>) & {
-			label: 'Dim';
-			name: 'dim';
-		};
-		FDUP: (() => Promise<boolean>) & {
-			label: 'Fade Up';
-			name: 'fadeUp';
-		};
-		FDDOWN: (() => Promise<boolean>) & {
-			label: 'Fade Down';
-			name: 'fadeDown';
-		};
-		FDSTOP: (() => Promise<boolean>) & {
-			label: 'Fade Stop';
-			name: 'fadeStop';
-		};
-		QUERY: (() => Promise<boolean>) & {
-			label: 'Query';
-			name: 'query';
-		};
-		BEEP: ((value?: number) => Promise<boolean>) & {
-			label: 'Beep';
-			name: 'beep';
-		};
-		OL: ((value: number) => Promise<boolean>) & {
-			label: 'On Level';
-			name: 'updateOnLevel';
-		};
-		RR: ((value: number) => Promise<boolean>) & {
-			label: 'Ramp Rate';
-			name: 'updateRampRate';
-		};
-		BL: ((value: number) => Promise<boolean>) & {
-			label: 'Backlight';
-			name: 'backlight';
-		};
-		WDU: (() => Promise<boolean>) & {
-			label: 'Write Changes';
-			name: 'writeChanges';
-		};
-	};
-	export type Drivers = {
-		ST: {
-			uom: UnitOfMeasure.LevelFrom0To255;
-			value: number;
-			label: 'Status';
-			name: 'status';
-		};
-		OL: {
-			uom: UnitOfMeasure.Percent;
-			value: number;
-			label: 'On Level';
-			name: 'onLevel';
-		};
-		RR: {
-			uom: UnitOfMeasure.Index;
-			value: number;
-			label: 'Ramp Rate';
-			name: 'rampRate';
-		};
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: 'Responding';
-			name: 'responding';
-		};
-	};
-}

package/src/Devices/Insteon/InsteonRelaySwitchDevice.ts

@@ -1,11 +0,0 @@
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import type { ISY } from '../../ISY.js';
-
-import { InsteonRelayDevice } from './InsteonRelayDevice.js';
-import 'winston';
-
-export class InsteonRelaySwitchDevice extends InsteonRelayDevice {
-	constructor (isy: ISY, deviceNode: NodeInfo ) {
-		super(isy, deviceNode);
-	}
-}

package/src/Devices/Insteon/RelayLampSwitch.ts

@@ -1,132 +0,0 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
-import { Driver } from '../../Definitions/Global/Drivers.js';
-import { Command } from '../../Definitions/index.js';
-import { Family } from '../../Definitions/Global/Families.js';
-import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
-import { Insteon } from '../../Definitions/index.js';
-import type { ISY } from '../../ISY.js';
-import type { ISYNode } from '../../ISYNode.js';
-import type { DriverState } from '../../Model/DriverState.js';
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import { ISYDeviceNode } from '../ISYDeviceNode.js';
-import { NodeFactory } from '../NodeFactory.js';
-import { InsteonBaseDevice } from './InsteonBaseDevice.js';
-
-export const nodeDefId = 'RelayLampSwitch';
-
-type Commands = RelayLampSwitch.Commands;
-type Drivers = RelayLampSwitch.Drivers;
-
-export class RelayLampSwitchNode extends InsteonBaseDevice<Drivers, Commands> implements RelayLampSwitch.Interface {
-	public override readonly commands = {
-		DON: this.on,
-		DOF: this.off,
-		DFOF: this.fastOff,
-		DFON: this.fastOn,
-		QUERY: this.query,
-		BEEP: this.beep,
-		BL: this.backlight,
-		WDU: this.writeChanges
-	};
-	static override nodeDefId = 'RelayLampSwitch';
-	declare readonly nodeDefId: 'RelayLampSwitch';
-	constructor(isy: ISY, nodeInfo: NodeInfo) {
-		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create('ST', this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Boolean, 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('DOF');
-	}
-	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 backlight(value: number) {
-		return this.sendCommand('BL', { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand('WDU');
-	}
-	public get status(): boolean {
-		return this.drivers.ST?.value;
-	}
-	public get responding(): Insteon.Error {
-		return this.drivers.ERR?.value;
-	}
-}
-
-NodeFactory.register(RelayLampSwitchNode);
-
-export namespace RelayLampSwitch {
-	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: 'RelayLampSwitch';
-	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchNode {
-		return node.nodeDefId === nodeDefId;
-	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new RelayLampSwitchNode(isy, nodeInfo);
-	}
-	export const Node = RelayLampSwitchNode;
-	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';
-		};
-		BL: ((value: number) => Promise<boolean>) & {
-			label: 'Backlight';
-			name: 'backlight';
-		};
-		WDU: (() => Promise<boolean>) & {
-			label: 'Write Changes';
-			name: 'writeChanges';
-		};
-	};
-	export type Drivers = {
-		ST: {
-			uom: UnitOfMeasure.Boolean;
-			value: boolean;
-			label: 'Status';
-			name: 'status';
-		};
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: 'Responding';
-			name: 'responding';
-		};
-	};
-}