isy-nodejs 1.0.8-alpha.0 → 1.3.24

package/src/Devices/CompositeDevice.ts

@@ -1,192 +1,298 @@
+import type { Constructor } from 'type-fest';
+import type { Feature } from '../Definitions/Global/Features.js';
+import { Category, Family } from '../Definitions/index.js';
+import { isDynamic, ISY } from '../ISY.js';
+import { ISYDevice } from '../ISYDevice.js';
+import { ISYNode } from '../ISYNode.js';
 
-import type { Driver } from '../Definitions/Global/Drivers.js';
-import type { UnitOfMeasure } from '../Definitions/Global/UOM.js';
-
-import type { ISYDevice } from '../ISYDevice.js';
-import { DriverMap, ISYNode, NodeList } from '../ISYNode.js';
-import type { ISYScene } from '../ISYScene.js';
-import type { DriverState } from '../Model/DriverState.js';
-import type { Category, Family } from '../Definitions/index.js';
-import { ISY } from '../ISY.js';
 import type { NodeInfo } from '../Model/NodeInfo.js';
-import { NodeFactory } from './NodeFactory.js';
-import type { Constructor } from 'type-fest';
+import type { ISYScene } from '../Scenes/ISYScene.js';
+import type { Factory as BaseFactory, InstanceOf, ObjectToUnion, StringKeys } from '../Utils.js';
 import type { ISYDeviceNode } from './ISYDeviceNode.js';
-import type { ObjectToUnion, StringKeys } from '../Utils.js';
-
-import type { Fan } from './Insteon/InsteonFanDevice.js';
-
 
- export type CompositeDevice<F extends Family, N extends {[x: string]: ISYDeviceNode<F,any,any,any>},R = N[keyof N]> =
-{[x in keyof N]: N[x]} & {
+export type CompositeDevice<F extends Family, N extends { [x: string]: ISYNode.Factory<F, any> }, R = N[keyof N]> = {
+	[x in keyof N]: InstanceOf<N[x]>;
+} & {
+	root: R | null;
 
-	root: R;
+	events: { [x in keyof N]: InstanceType<N[x]['Class']>['events'] };
 
-	events: { [x in keyof N]: N[x]['events'] };
+	drivers: { [x in keyof N]: InstanceType<N[x]['Class']>['drivers'] };
 
-	drivers: { [x in keyof N]:  N[x]['drivers'] };
+	commands: { [x in keyof N]: InstanceType<N[x]['Class']>['commands'] };
+	nodes: { [x in keyof N]: InstanceType<N[x]['Class']> };
 
-	commands: { [x in keyof N]: N[x]['commands'] };
+	applyNodeDefs(): Promise<void>;
 
-	addNode: (node: NodeInfo | ISYNode, isy?: ISY) => void;
+	refreshNotes(): Promise<void>;
 
+	addNode: (node: NodeInfo | ISYNode, isy?: ISY) => void | Promise<void>;
+} & Omit<ISYDevice<F, unknown, unknown, unknown>, 'drivers' | 'commands' | 'events'>;
 
+export namespace CompositeDevice {
+	export type DriversOf<N extends CompositeDevice<any, any>> = N['drivers'];
 
-} & ISYDevice<Family, any,unknown,any>;
+	export type CommandsOf<N extends CompositeDevice<any, any>> = N['commands'];
 
-export namespace CompositeDevice {
-	export type DriversOf<N extends CompositeDevice<any,any>> = N['drivers'];
+	export type EventsOf<N extends CompositeDevice<any, any>> = N['events'];
 
-	export type CommandsOf<N extends CompositeDevice<any,any>> = N['commands'];
+	export type DriverNamesOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{
+		[x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.DriverNamesOf<N[x]> & string}`;
+	}>;
 
-	export type EventsOf<N extends CompositeDevice<any,any>> = N['events'];
+	export type CommandNamesOf<N> =
+		N extends BaseFactory<CompositeDevice<any, infer X>> ? CommandNamesOf<X[keyof X]> : never;
 
-	export type DriverNamesOf<N extends CompositeDevice<any,any>> = ObjectToUnion<{[x in StringKeys<DriversOf<N>>] : `${x}.${ISYNode.DriverNamesOf<N[x]> & string}`}>;
+	export type EventNamesOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{
+		[x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.EventNamesOf<N[x]> & string}`;
+	}>;
 
-	export type CommandNamesOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{ [x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.CommandNamesOf<N[x]> & string}` }>;
+	export type DriverKeysOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{
+		[x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.DriverKeysOf<N[x]> & string}`;
+	}>;
 
-	export type EventNamesOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{ [x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.EventNamesOf<N[x]> & string}` }>;
+	export type CommandKeysOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{
+		[x in StringKeys<CommandsOf<N>>]: `${x}.${ISYNode.CommandKeysOf<N[x]> & string}`;
+	}>;
 
-	export type DriverKeysOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{ [x in StringKeys<DriversOf<N>>]: `${x}.${ISYNode.DriverKeysOf<N[x]> & string}` }>;
+	export type Any = CompositeDevice<Family, { [x: string]: ISYNode.Factory<Family, any> }>;
 
-	export type CommandKeysOf<N extends CompositeDevice<any, any>> = ObjectToUnion<{ [x in StringKeys<CommandsOf<N>>]: `${x}.${ISYNode.CommandKeysOf<N[x]> & string}` }>;
+	//@ts-ignore
+	type test = DriverNamesOf<FanDevice>;
 
-	export function of<F extends Family, N extends { [x: string]: ISYDeviceNode<any, any, any, any> }>(nodes: { [x in keyof N]: Constructor<N[x]> }, keyFunction: (node: NodeInfo) => [keyof N, boolean]): Constructor<CompositeDevice<F, N>>;
-	export function of<F extends Family, N extends { [x: string]: ISYDeviceNode<any, any, any, any> }>(nodes: { [x in keyof N]: Constructor<N[x]> }, keyMap: {[x in keyof N]: number | string}): Constructor<CompositeDevice<F, N>>;
-	export function of<F extends Family, N extends { [x: string]: ISYDeviceNode<any, any, any, any> }>(nodes: { [x in keyof N]: Constructor<N[x]> }, keyFunction: {[x in keyof N]: number | string} |((node: NodeInfo) => [keyof N, boolean])): Constructor<CompositeDevice<F, N>> {
-		if(keyFunction === undefined) {
+	export function of<F extends Family, N extends { [x: string]: ISYNode.Factory<F, any> }>(
+		nodes: N,
+		keyFunction: (node: NodeInfo) => [keyof N, boolean]
+	): Constructor<CompositeDevice<F, N>>;
+	export function of<F extends Family, N extends { [x: string]: ISYNode.Factory<F, any> }>(
+		nodes: N,
+		keyMap: { [x in keyof N]: number | string }
+	): Constructor<CompositeDevice<F, N>>;
+	export function of<F extends Family, N extends { [x: string]: ISYNode.Factory<F, any> }>(
+		nodes: N,
+		keyFunction: { [x in keyof N]: number | string } | ((node: NodeInfo) => [keyof N, boolean])
+	): Constructor<CompositeDevice<F, N> & ISYDevice<F, any, any, any>> {
+		if (keyFunction === undefined) {
 			keyFunction = (node: NodeInfo) => [node.name, true];
 		}
-		if(typeof keyFunction === 'function') {
+		if (typeof keyFunction === 'function') {
 			return CompositeOf(nodes, keyFunction as any);
-		}
-		else if(typeof keyFunction === 'object') {
-			return CompositeOf(nodes, (node: NodeInfo | ISYNode) => {for (const key in keyFunction)
-			{
-				if(node.address.endsWith(keyFunction[key].toString())) {
-					return [key, keyFunction[key] == 1 || keyFunction[key] == '1'];
+		} else if (typeof keyFunction === 'object') {
+			const keyIndex = keyFunction as { [x in keyof N]: number | string };
+			return CompositeOf(nodes, (node: NodeInfo | ISYNode) => {
+				for (const key in keyIndex) {
+					if (node instanceof ISYNode) {
+						// Handle ISYNode case if needed
+					} else if (isDynamic(node) && node.nodeTypeId == `${keyIndex[key]}`) {
+						return [key, node.pnode == node.address] as any;
+					}
+					if (node.address.endsWith(keyIndex[key].toString())) {
+						return [key, keyIndex[key] == 1 || keyIndex[key] == '1'];
+					}
 				}
-			}});
-
-
-
+				// Return a default value if no match is found
+				return [Object.keys(keyIndex)[0] as keyof N, false] as any;
+			});
 		}
+		// This should never be reached, but TypeScript needs a return
+		throw new Error('Invalid keyFunction parameter');
+	}
 
+	export interface Factory<
+		F extends Family,
+		N extends { [x: string]: ISYNode.Factory<F, any> },
+		C extends CompositeDevice<F, N>,
+	> extends BaseFactory<C> {
+		//Drivers: { [x in keyof N]: N[x]['Drivers'] };
+		//Commands: { [x in keyof N]: [N[x]['Commands']] };
+		Nodes: N;
 	}
 
 	export function isComposite(device: ISYDevice<any, any, any, any>): device is CompositeDevice<any, any> {
 		return 'addNode' in device;
 	}
-
+	//@ts-ignore
 }
 
+export function CompositeOf<F extends Family, N extends { [x: string]: ISYNode.Factory<F, any> }>(
+	nodes: N,
+	keyFunction: (node: NodeInfo | ISYNode) => [keyof N, boolean]
+): Constructor<CompositeDevice<F, N>> {
+	return class implements ISYDevice<F, any, any, any> {
+		readonly isy: ISY;
+
+		/*public static async create(...args: any[]): Promise<CompositeDevice<F, N>> {
+			const d = new class(args) as any as CompositeDevice<F, N>;
+			let isy = d.isy;
+			for (const n in d.nodes) {
+				const node = d.nodes[n] as ISYNode;
+				if ('getNodeDef' in node && typeof node.getNodeDef == 'function' && 'applyNodeDef' in node && typeof node.applyNodeDef == 'function') {
+				}
+			}
+			return d;
+		}*/
 
-export function CompositeOf <F extends Family, N extends {[x: string]: ISYDeviceNode<any,any,any,any>}>(nodes: {[x in keyof N]: Constructor<N[x]>}, keyFunction: (node: NodeInfo | ISYNode) => [keyof N,boolean]) : Constructor<CompositeDevice<F,N>>
-{
-return class implements ISYDevice<Family, any, unknown, any> {
-	readonly isy: ISY;
-
-	constructor(...args: any[]) {
-
-		if(args[0] instanceof ISY) {
-			this.isy = args.shift();
-			for (const nodeInfo of args as NodeInfo[]) {
+		constructor(...args: any[]) {
+			if (args[0] instanceof ISY) {
+				this.isy = args.shift();
 
-				this.addNode(nodeInfo, this.isy);
+				for (const nodeInfo of args as NodeInfo[]) {
+					this.addNode(nodeInfo, this.isy);
+				}
+			}
+		}
+		category: F extends Family.Insteon ? Category.Insteon : Category.Home.Category;
+		deviceClass: any;
+		enabled: boolean;
+		family: F;
+		hidden: boolean;
+		isDimmable: boolean;
+		label: string;
+		model: string;
+		modelNumber: string;
+		name: any;
+		parentAddress: any;
+		productName: string;
+		scenes: ISYScene[];
+		subCategory: number;
+		type: any;
+		typeCode: string;
+		version: string;
+		manufacturer: string;
+		productId: string | number;
+		modelName: string;
+
+		location: string;
+
+		features: Feature;
+
+		async query(): Promise<void> {
+			for (const n in this.nodes) {
+				let node = this.nodes[n];
+				if (ISYDevice.isQueryable(node)) {
+					await node.query();
+				}
 			}
 		}
 
-	}
-	category: Category;
-	deviceClass: any;
-	enabled: boolean;
-	family: Family;
-	hidden: boolean;
-	isDimmable: boolean;
-	label: string;
-	model: string;
-	modelNumber: string;
-	name: any;
-	parentAddress: any;
-	productName: string;
-	scenes: ISYScene[];
-	subCategory: number;
-	type: any;
-	typeCode: string;
-	version: string;
-	vendorName: string;
-	productId: string | number;
-	modelName: string;
-	manufacturer: string;
-
-	public address: string;
-
-
-	public events: { [x in keyof N]: N[x]['events'] } = {} as any;
-
-	public drivers: { [x in keyof N]:  N[x]['drivers'] } = {} as any;
-
-	public commands: { [x in keyof N]:  N[x]['commands'] } = {} as any;
-
-	public root = null;
-
-	public addNode(node: ISYNode): void;
-	public addNode(node: NodeInfo, isy: ISY): void;
-	public addNode(node: NodeInfo | ISYNode, isy = this.isy) {
-
-		let n : ISYDeviceNode<any, any, any, any> = null;
-		if(node instanceof ISYNode) {
-			n = node as ISYDeviceNode<any, any, any, any>;
+		async refreshState(): Promise<void> {
+			for (const n in this.nodes) {
+				let node = this.nodes[n];
+				await node.refreshState();
+			}
 		}
-		else
-		{
-			n = new nodes[keyFunction(node)[0]](isy, node);
+
+		public async applyNodeDefs(): Promise<void> {
+			for (const n in this.nodes) {
+				let node = this.nodes[n] as ISYDeviceNode<F, any, any, any>;
+				if (ISYDevice.isDynamic(node)) {
+					await node.applyNodeDef();
+				}
+			}
 		}
-		const keyL = keyFunction(node);
-		const key = keyL[0];
-		const isRoot = keyL[1];
-
-		Object.defineProperty(this, key, n);
-
-		Object.defineProperty(this.events, key, { get(): () => any { return this[key].events; } });
-		Object.defineProperty(this.drivers, key, { get(): () => any { return this[key].drivers; } });
-		Object.defineProperty(this.commands, key, { get(): () => any { return this[key].commands; } });
-		if(isRoot) {
-			this.address = node.address;
-			this.family = n.family;
-			this.category = n.category;
-			this.deviceClass = n.deviceClass;
-			this.enabled = n.enabled;
-			this.hidden = n.hidden;
-			this.isDimmable = n.isDimmable;
-			this.label = n.label;
-			this.model = n.model;
-			this.modelNumber = n.modelNumber;
-			this.name = n.name;
-			this.parentAddress = n.parentAddress;
-			this.productName = n.productName;
-			this.scenes = n.scenes;
-			this.subCategory = n.subCategory;
-			this.type = n.type;
-			this.typeCode = n.typeCode;
-			this.version = n.version;
-			this.vendorName = n.vendorName;
-			this.productId = n.productId;
-			this.modelName = n.modelName;
-			this.manufacturer = n.manufacturer;
-			this.root = n;
 
+		_initialized = false;
+		public get initialized(): boolean {
+			if (!this._initialized)
+				for (const key in this.nodes) {
+					if (!this.nodes[key]?.initialized) {
+						return false;
+					}
+				}
+			this._initialized = true;
+			return true;
 		}
 
-	}
+		public address: string;
 
-  } as unknown as Constructor<CompositeDevice<F,N>>;
+		public events: { [x in keyof N]: InstanceOf<N[x]>['events'] } = {} as any;
 
+		public drivers: { [x in keyof N]: InstanceType<N[x]['Class']>['drivers'] } = {} as any;
 
-}
+		public commands: { [x in keyof N]: InstanceType<N[x]['Class']>['commands'] } = {} as any;
 
+		public nodes: { [x in keyof N]: InstanceType<N[x]['Class']> } = {} as any;
 
+		public async refreshNotes(): Promise<void> {
+			for (const key in this.nodes) {
+				await this.nodes[key].refreshNotes();
+			}
+			return Promise.resolve();
+		}
+		public root: ISYDeviceNode<F, any, any, any> | null = null;
+
+		public async addNode(node: ISYNode): Promise<void>;
+		public async addNode(node: NodeInfo, isy: ISY): Promise<void>;
+		public async addNode(node: NodeInfo | ISYNode, isy = this.isy) {
+			let n: ISYDeviceNode<F, any, any, any> | null = null;
+			if (node instanceof ISYNode) {
+				n = node as unknown as ISYDeviceNode<any, any, any, any>;
+			} else {
+				const key = keyFunction(node)[0];
+				const nodeFactory = nodes[key];
+				if (nodeFactory?.create) {
+					n = await nodeFactory.create(isy, node);
+				} else {
+					throw new Error(`No factory found for node key: ${String(key)}`);
+				}
+			}
 
+			if (!n) {
+				throw new Error('Failed to create node');
+			}
+
+			const keyL = keyFunction(node);
+			const key = keyL[0];
+			const isRoot = keyL[1];
+			this.nodes[key] = n as InstanceType<N[typeof key]['Class']>;
+
+			//@ts-ignore
+			this[key] = n;
+
+			Object.defineProperty(this.events, key, {
+				get(): () => any {
+					return this[key].events;
+				},
+			});
+			Object.defineProperty(this.drivers, key, {
+				get(): () => any {
+					return this[key].drivers;
+				},
+			});
+			Object.defineProperty(this.commands, key, {
+				get(): () => any {
+					return this[key].commands;
+				},
+			});
+			if (isRoot) {
+				this.address = node.address;
+				this.family = n.family;
+				this.category = n.category;
+				this.deviceClass = n.deviceClass;
+				this.enabled = n.enabled;
+				this.hidden = n.hidden;
+				this.isDimmable = n.isDimmable;
+				this.label = n.label;
+				this.model = n.model;
+				this.modelNumber = n.modelNumber;
+				this.name = n.name;
+				this.parentAddress = n.parentAddress;
+				this.productName = n.productName;
+				this.scenes = n.scenes;
+				this.subCategory = n.subCategory;
+				this.type = n.type;
+				this.typeCode = n.typeCode;
+				this.version = n.version;
+				this.manufacturer = n.manufacturer;
+				this.productId = n.productId;
+				this.modelName = n.modelName;
+				this.manufacturer = n.manufacturer;
+				this.location = n.location;
+				this.root = n;
+			}
+		}
+	} as unknown as Constructor<CompositeDevice<F, N>>;
+}
 
 /*
 

package/src/Devices/Constructor.ts

@@ -1,4 +1,3 @@
+import { Constructor as BaseConstructor } from 'type-fest';
 
-
-
-export type Constructor<T> = new (...args: any[]) => T & T;
+export type Constructor<T> = BaseConstructor<T>;

package/src/Devices/DeviceFactory.ts

@@ -1,27 +1,93 @@
-
 import { Family } from '../Definitions/Global/Families.js';
-import { NodeInfo } from '../Model/NodeInfo.js';
-import type { ISYDevice } from '../ISYDevice.js';
-import type { Constructor } from './Constructor.js';
+import type { ISY } from '../ISY.js';
+import { ISYDevice } from '../ISYDevice.js';
+//@ts-ignore
+import { NodeInfo, cleanNodeInfo } from '../Model/NodeInfo.js';
 import { InsteonDeviceFactory } from './Insteon/InsteonDeviceFactory.js';
-import type { StringKeys } from '../Utils.js';
-import { ISYNode } from '../ISYNode.js';
-
+import { NodeFactory } from './NodeFactory.js';
+import { ZigBeeDeviceFactory } from './ZigBee/ZigBeeDeviceFactory.js';
 
 export class DeviceFactory {
+	static async createAll(isy: ISY, ...nodeInfos: NodeInfo[]) {
+		const devices = await Promise.all(
+			nodeInfos.map(async node => {
+				return await this.create(isy, node);
+			})
+		);
+		for (const device of devices) {
+			if (ISYDevice.isComposite(device)) {
+				for (const child of this.nodeMap.get(device.node.address) ?? []) {
+					device.addNode(child, isy);
+				}
+			}
+		}
+		return devices;
+	}
 
-	public static getDeviceDetails(node: NodeInfo): { name: string; modelNumber?: string; version?: string; class?: Constructor<ISYDevice<Family,any,any,any>>; unsupported?: true } {
-
+	static nodeMap = new Map<string, NodeInfo<Family>[]>();
 
-		if ((node.family ?? Family.Insteon) == Family.Insteon) {
+	static async addChildNodes(isy: ISY) {
+		isy.logger.debug('Adding child nodes. Composite Device Count: ' + DeviceFactory.nodeMap.size);
 
-			return InsteonDeviceFactory.getDeviceDetails(node) as any;
+		for (const [address, nodeInfos] of DeviceFactory.nodeMap) {
+			isy.logger.debug('Adding child nodes for: ' + address + '. Child Count: ' + nodeInfos.length);
+			const parent = isy.getDevice(address);
+			if (parent && ISYDevice.isComposite(parent)) {
+				for (const nodeInfo of nodeInfos) {
+					await parent.addNode(nodeInfo, isy);
+				}
+				await parent.applyNodeDefs();
+			} else {
+				isy.logger.debug('Parent not found for: ' + address);
 
-		} else { return {name: 'Unsupported Device', class: null, unsupported: true} }
+				for (const nodeInfo of nodeInfos) {
+					try {
+						await NodeFactory.create(nodeInfo, isy);
+					} catch {}
+				}
+			}
+		}
 	}
 
+	static async create<T extends Family>(isy: ISY, nodeInfo: NodeInfo<T>): Promise<ISYDevice<T, any, any, any>> {
+		const cinfo = cleanNodeInfo(nodeInfo);
 
+		if (cinfo.pnode != cinfo.address) {
+			let nodeInfos = DeviceFactory.nodeMap.get(cinfo.pnode) ?? [];
+			nodeInfos.push(cinfo);
+			DeviceFactory.nodeMap.set(nodeInfo.pnode, nodeInfos);
+			return null;
+		}
+
+		let device = null as ISYDevice<T, any, any, any>;
+		switch (cinfo.family) {
+			case Family.Insteon:
+				//@ts-ignore
+				device = await InsteonDeviceFactory.create(isy, cinfo);
+				break;
+			case Family.ZigBee:
+				device = (await ZigBeeDeviceFactory.create(isy, cinfo)) as any;
+				break;
+			default:
+				device = null;
+				break;
+		}
+		if (!device) {
+			device = (await NodeFactory.create(cinfo, isy)) as any;
+		}
+		/*if (!device) {
+			return new GenericNode(isy, nodeInfo) as any;
+		}*/
+		return device;
+	}
 }
-export namespace NodeFactory {
 
+export namespace DeviceFactory {
+	export const Insteon = InsteonDeviceFactory;
+	export type ZWave = {};
+	export type ZigBee = ZigBeeDeviceFactory;
+
+	export const ZigBee = ZigBeeDeviceFactory;
+
+	export type Insteon = typeof InsteonDeviceFactory;
 }

package/src/Devices/DeviceMap.ts

@@ -1,43 +1,63 @@
-
-
-import { Insteon, Family } from '../Definitions/Global/Families.js';
 import { Category } from '../Definitions/Global/Categories.js';
-import type { ISYDevice } from '../ISYDevice.js';
-import type { Devices } from './index.js';
-import type { Device } from '@project-chip/matter.js/device';
-import type { getCategory } from '../Utils.js';
+import { Family } from '../Definitions/Global/Families.js';
+import type { Feature } from '../Definitions/Global/Features.js';
+import type { PickOfType } from '../Utils.js';
+import type * as Devices from './index.js';
 
 // tslint:disable-next-line: no-unused-expression
 // tslint:disable-next-line: no-angle-bracket-type-assertion
 
-type s<T extends Family> = ISYDevice<T,any,any,any>;
-
-type DeviceNames<T extends Family> = `${T extends Family.Insteon | Family.ZWave | Family.ZigBee ? Devices<T>[keyof Devices<T>]["constructor"]["name"] : ""}`;
-type x = DeviceNames<Family.Insteon>
-export interface DeviceDef<T extends Family>
-{
-		id: number;
-		type?: string;
-		name: string;
-		modelNumber?: string;
-		class?: DeviceNames<T>;
+//type s<T extends Family> = ISYDevice<T, any, any, any>;
+
+//type DeviceNames<T extends Family> = `${T extends Family.Insteon | Family.ZWave | Family.ZigBee ? StringKeyOf< : never}`;
+//type x = DeviceNames<Family.Insteon>;
+
+type LabelFor<T extends number> = T extends Family.Insteon | Family.ZWave | Family.ZigBee
+	? PickOfType<typeof Family, T>
+	: never;
+
+export interface DeviceDef<T> {
+	id: number;
+	type?: string;
+	name: string;
+	modelNumber?: string;
+	//@ts-ignore
+	class?: keyof (typeof Devices)[LabelFor<T>];
+	features?: Feature;
 }
 
-export interface CategoryDef<T extends Family, C extends Category> {
+export interface CategoryDef<T extends Family, C extends Category.Insteon> {
 	id: C;
-	name: `${typeof Category[C]}`;
-	devices: {[x:number]: DeviceDef<T>}
+	name: string;
+	devices: { [x: number]: DeviceDef<T> };
 }
 
 export interface FamilyDef<T extends Family> {
 	id: T;
-	name: keyof typeof Family;
+	name: string;
 	description: string;
-	categories: {[key in keyof typeof Category]?: CategoryDef<T,typeof Category[key]> & {name: key}};
+
+	manufacturer?: string;
+	categories: { [key in keyof typeof Category.Insteon]?: CategoryDef<T, (typeof Category.Insteon)[key]> };
 }
 
-var s : FamilyDef<Family.Insteon> = { id: Family.Insteon, description: "Insteon", name: "Insteon", categories: {DimmableControl: {id: Category.DimmableControl, name: "DimmableControl", devices: {1:{id: 0, name: "DimmableControl"}}}}};
+/*var s : FamilyDef<Family.Insteon> = { id: Family.Insteon, description: "Insteon", name: "Insteon", categories: {DimmableControl: {id: Category.Insteon.DimmableControl, name: "DimmableControl", devices: {1:{id: 0, name: "DimmableControl"}}}}};*/
 
 export type DeviceMap = {
-  [key in keyof typeof Family]?: FamilyDef<(typeof Family)[key]> & { name: key };
+	[key in keyof typeof Family]?: FamilyDef<(typeof Family)[key]> & { name: key };
 };
+
+/*export function register(deviceMap: DeviceMap) {
+	for (const key in deviceMap) {
+		const element = deviceMap[key];
+		for (const catKey in element.categories) {
+			for (const devKey in element.categories[catKey].devices) {
+				const dev = element.categories[catKey].devices[devKey];
+				const device = Devices[key][dev.class as string];
+				if (device) {
+					device.typeCodes.push(dev.type ?? dev.name);
+				}
+			}
+		}
+	}
+}*/