isy-nodejs 1.0.5-alpha.1 → 1.0.6-alpha.1

package/src/Matter/Behaviors/ISYBridgedDeviceBehavior.ts

@@ -7,16 +7,13 @@ import { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
 
 import { EventEmitter, Observable } from '@project-chip/matter.js/util';
 import internal from 'stream';
+import { server } from 'typescript';
 import type { Driver } from '../../Definitions/Global/Drivers.js';
+import type { Family } from '../../Definitions/index.js';
 import { ISY } from '../../ISY.js';
 import type { ISYDevice } from '../../ISYDevice.js';
-import { server } from 'typescript';
 import type { ISYNode } from '../../ISYNode.js';
-import type { Family } from '../../Definitions/index.js';
-import { MappingRegistry, type BehaviorMapping, type DeviceToClusterMap } from '../Mappings/MappingRegistry.js';
-
-
-
+import { MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../Mappings/MappingRegistry.js';
 
 type ClusterForBehavior<B extends ClusterBehavior> = B extends ClusterBehavior.Type<infer C> ? C : never;
 export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D extends ISYNode.DriverSignatures = ISYNode.DriverSignatures> extends Behavior {
@@ -27,7 +24,7 @@ export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D ext
 	declare internal: ISYBridgedDeviceBehavior.Internal;
 	declare state: ISYBridgedDeviceBehavior.State;
 
-	declare events: ISYBridgedDeviceBehavior.Events & ISYBridgedDeviceBehavior.EventsFor<N["drivers"]>;
+	declare events: ISYBridgedDeviceBehavior.Events & ISYBridgedDeviceBehavior.EventsFor<N['drivers']>;
 
 	override async initialize(_options?: {}) {
 		await super.initialize(_options);
@@ -40,20 +37,15 @@ export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D ext
 		if (d) {
 			d.events.on('propertyChanged', this.handlePropertyChange.bind(this));
 
-			for(const f in d.drivers)
-			{
+			for (const f in d.drivers) {
 				let evt = `${d.drivers[f].name}Changed`;
 				const obs = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
 
-
-
 				d.events.on(evt, (driver: string, newValue: any, oldValue: any, formattedValue: string) => obs.emit({ driver, newValue, oldValue, formattedValue }));
 				this.events[evt] = obs;
 
-
 				//@ts-ignore
 				//d.events.on(evt, (driver: string, newValue: any, oldValue: any, formattedValue: string) => this.events.emit(evt, { driver, newValue, oldValue, formattedValue } as unknown as any));
-
 			}
 		}
 	}
@@ -66,21 +58,17 @@ export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D ext
 		return this.internal.map;
 	}
 
-	mapForBehavior<B extends ClusterBehavior>(behavior: B): BehaviorMapping<B, typeof this.internal.device> {
-		return this.map.mapping[behavior.cluster['name']];
+	mapForBehavior<B extends ClusterBehavior>(behavior: B): ClusterMapping<B, typeof this.internal.device> {
+		return this.map.mapping[behavior.cluster.name];
 	}
 
 	handlePropertyChange(driver: string, newValue: any, oldValue: any, formattedValue: string) {
-
 		this.events.propertyChanged.emit({ driver, newValue, oldValue, formattedValue });
-
-
 	}
 
 	override [Symbol.asyncDispose]() {
-
 		this.internal.device = null;
-
+		
 
 		return super[Symbol.asyncDispose]();
 	}
@@ -92,18 +80,12 @@ export namespace ISYBridgedDeviceBehavior {
 		map?: DeviceToClusterMap<typeof this.device, any>;
 	}
 
-	export type EventsFor<D extends {[x: string]: Driver<any,any,any>}> = {
-		[s in keyof D as `${D[s]["name"]}Changed`] : Observable<[{ driver: s; newValue: any; oldValue: any; formattedValue: string }]>;
-	}
-
+	export type EventsFor<D extends { [x: string]: Driver<any, any, any> }> = {
+		[s in keyof D as `${D[s]['name']}Changed`]: Observable<[{ driver: s; newValue: any; oldValue: any; formattedValue: string }]>;
+	};
 
-
-
-	export class Events extends EventEmitter{
+	export class Events extends EventEmitter {
 		propertyChanged = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
-
-
-
 	}
 
 	export class State {

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -5,8 +5,9 @@ import { Converter } from '../../Converters.js';
 import type { Constructor } from '../../Devices/Constructor.js';
 import type { DriversOf, ISYNode } from '../../ISYNode.js';
 
+import type { ClusterMapping } from '../Mappings/MappingRegistry.js';
 import { ISYBridgedDeviceBehavior } from './ISYBridgedDeviceBehavior.js';
-import type { BehaviorMapping } from '../Mappings/MappingRegistry.js';
+import { isYieldExpression } from 'typescript';
 
 // #region Type aliases (6)
 
@@ -20,7 +21,7 @@ export type DeviceBehavior<P extends ISYNode<any, any, any, any>, T extends { cl
 	bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 
 	//ts-ignore
-	map: BehaviorMapping<T, P>;
+	map: ClusterMapping<T, P>;
 
 	handlePropertyChange(chg: PropertyChange<P>): void;
 };
@@ -49,7 +50,7 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 		bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 		///public map: ClusterMapping<ToClusterTypeByName<ClusterForBehavior<ConstructedType<typeof base>>["name"]>,ISYDeviceNode<any, any, any>>;
 
-		map: BehaviorMapping<T, P>;
+		map: ClusterMapping<T, P>;
 
 		override async initialize(_options?: {}) {
 			await super.initialize(_options);
@@ -58,6 +59,7 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 			this.bridgedDeviceBehavior = behavior;
 			//var behavior = this.agent.get(ISYBridgedDeviceBehavior);
 			this._device = behavior.device as P;
+			this._device.logger('Initializing cluster behavior');
 			//@ts-ignore
 
 			this.map = behavior.mapForBehavior<T>(this as unknown as T);
@@ -70,17 +72,16 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 					this.handlers[val] = (newValue, oldValue, formattedValue) => {
 						this.state[key2 as string] = newValue;
 					};
-
-				} else if (val.driver as DriversOf<P>) {
+				} else if (val.driver as keyof DriversOf<P>) {
 					driverObj = this._device.drivers[val.driver as string];
 
 					let { driver, converter } = val;
 					const convFunc = Converter.get(converter)?.to;
-					if(!convFunc) throw new Error(`Converter ${converter} not found`);
+					if (!convFunc) throw new Error(`Converter ${converter} not found`);
 					this.state[key2 as string] = convFunc(this._device.drivers[driver as string].value);
 					this.handlers[driver] = (newValue, oldValue, formattedValue) => {
 						//if (convFunc) this.state[key2 as string] = convFunc(newValue);
-						 this.state[key2 as string] = convFunc(newValue);
+						this.state[key2 as string] = convFunc(newValue);
 					};
 				}
 				if (driverObj) {

package/src/Matter/Bridge/Server.ts

@@ -354,7 +354,7 @@ async function initializeConfiguration(isy: ISY, config?: Config): Promise<Confi
 	});
 
 	logger.info(`Matter storage location: ${storageService.location} (Directory)`);
-	logger.info(`Matter storage service type: ${storageService.factory.name}`);
+	//logger.info(`Matter storage service type: ${storageService.factory.name}`);
 
 	const deviceStorage = (await storageService.open('bridge')).createContext('data');
 

package/src/Matter/Mappings/Insteon.ts

@@ -6,7 +6,7 @@ import * as Insteon from '../../Devices/Insteon/index.js';
 //import InsteonMap from "./Insteon.json";
 
 import { OnOffLightDevice, DimmableLightDevice } from '@matter/node/devices';
-import { add, MappingRegistry, type EndpointMapping, type FamilyToClusterMap } from './MappingRegistry.js';
+import {  MappingRegistry, type EndpointMapping, type FamilyToClusterMap } from './MappingRegistry.js';
 
 export const map: FamilyToClusterMap<Family.Insteon> = {
 	Family: Family.Insteon,
@@ -16,7 +16,7 @@ export const map: FamilyToClusterMap<Family.Insteon> = {
 		mapping: {
 			OnOff: {
 				attributes: {
-					onOff: { driver: 'ST', converter: 'Percent.Boolean' }
+					onOff: { driver: 'ST', converter: 'LightingLevel.Boolean' }
 				},
 				commands: { on: 'DON' }
 			}
@@ -44,7 +44,8 @@ export const map: FamilyToClusterMap<Family.Insteon> = {
 				},
 				commands: { on: 'DON' }
 			},
-			//@ts-ignore
+
+
 			LevelControl: {
 				// @ts-ignore
 				attributes: {
@@ -60,7 +61,7 @@ export const map: FamilyToClusterMap<Family.Insteon> = {
 		deviceType: DimmableLightDevice,
 		// @ts-ignore
 		mapping: {
-			// @ts-ignore
+			
 			OnOff: {
 				attributes: {
 					onOff: { driver: 'ST', converter: 'Percent.Boolean' }
@@ -81,9 +82,8 @@ export const map: FamilyToClusterMap<Family.Insteon> = {
 	}
 };
 
-map.KeypadDimmer = map.DimmerLamp;
-map.KeypadRelay = map.RelayLampSwitch;
-
+map.KeypadDimmer = {...map.DimmerLamp};
+map.KeypadRelay = {...map.RelayLamp};
 
 
 

package/src/Matter/Mappings/MappingRegistry.ts

@@ -1,34 +1,36 @@
-import * as Clusters from '@project-chip/matter.js/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 type { OnOffLightDevice } from '@matter/main/devices';
+import { DimmableLightDevice, 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 type { Constructor } from '../../Devices/Constructor.js';
 import { NodeFactory } from '../../Devices/NodeFactory.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 type { PathsWithLimit, PickOfType, Remove } from '../../Utils.js';
-import { ClusterType } from '../../Model/ClusterType.js';
-import type { Constructor } from '../../Devices/Constructor.js';
 
 // #region Type aliases (16)
 
 export type AttributeMapping<B, D> =
-	B extends { cluster: { attributes: infer E extends { [K in string]: Clusters.ClusterType.Attribute } } } ?
+	B extends { cluster: { attributes: infer E extends { [K in string]: Cluster.ClusterType.Attribute } } } ?
 		Partial<Record<keyof E, keyof DriversOf<D> | { driver: keyof DriversOf<D>; converter?: Converter.KnownConverters }>>
 	:	never;
-export type BehaviorMapping<B extends { cluster? }, T extends ISYNode<any, any, any, any>> = {
-	attributes?: AttributeMapping<B, T>;
-	commands?: CommandMapping<B, T>;
+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 Clusters.ClusterType.AttributesOf<A>]?: { driver: Extract<keyof DriversOf<K>, string>; converter?: (value: any) => any } | Extract<keyof DriversOf<K>, string>;
+	[key in keyof Cluster.ClusterType.AttributesOf<A>]: { driver: Extract<keyof DriversOf<K>, string>; converter?: Converter.KnownConverters } | Extract<keyof DriversOf<K>, string>;
 };
 // export type ClusterTypeCommandMapping<A extends ClusterType, K> = {
 //   [key in keyof Clusters.ClusterType.CommandsOf<ToCompleteClusterByName<A>>]?:
@@ -36,7 +38,7 @@ export type ClusterAttributeMapping<A, K> = {
 //     | CommandsOf<K>
 // };
 export type ClusterCommandMapping<A, K> = {
-	[key in keyof Clusters.ClusterType.CommandsOf<A>]?: { command: keyof CommandsOf<K>; parameters?: parameterMapping } | keyof CommandsOf<K>;
+	[key in keyof Cluster.ClusterType.CommandsOf<A>]: { command: keyof CommandsOf<K>; parameters?: parameterMapping } | keyof CommandsOf<K>;
 };
 //export type FamilyToDeviceMap<T extends Family> = Record<keyof Devices<T>, DeviceToClusterMap<ISYDevice<T>>>;
 
@@ -44,14 +46,14 @@ export type ClusterCommandMapping<A, K> = {
 //     attributes: ClusterTypeAttributeMapping<A,K>,
 //     commands: ClusterTypeCommandMapping<A,K>
 // };
-export type ClusterMapping<A, K> = {
+/*export type ClusterMapping<A, K> = {
 	attributes: ClusterAttributeMapping<A, K>;
 	commands: ClusterCommandMapping<A, K>;
-};
+};*/
 export type CommandMapping<B, D> =
 	B extends (
 		{
-			cluster: { commands: infer E extends { [K in string]: Clusters.ClusterType.Command } };
+			cluster: { commands: infer E extends { [K in string]: Cluster.ClusterType.Command } };
 		}
 	) ?
 		Partial<Record<keyof E, keyof CommandsOf<D> | { command: keyof CommandsOf<D>; parameters?: parameterMapping }>>
@@ -89,12 +91,43 @@ export type CommandMapping<B, D> =
 //     behavior?: typeof ClusterBehavior;
 
 // }
-export type 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>;
+		}
+		}
+	}
+
+
+
+}
+
+   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<PickOfType<A['behaviors'], ClusterBehavior>> as Capitalize<K>]?: A['behaviors'][K] extends ClusterBehavior ? BehaviorMapping<A['behaviors'][K], D> : undefined; //{
+	[K in StringKeys<A['behaviors']>]?: ClusterMapping<A['behaviors'][K],D> //{
 	/*attributes?: AttributeMapping<A['behaviors'][Uncapitalize<K>], D>;
 		commands?: CommandMapping<A['behaviors'][Uncapitalize<K>], D>;*/
 	//};
@@ -124,13 +157,20 @@ 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>;
 };
 
+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>, deviceClass: Constructor<T>,  mapping: DeviceToClusterMap<T, D> )
-{
-	 const map = {};
-	 map[deviceClass.name] = mapping;
+}
+
+export function add<const F extends SupportedFamily, const T extends ISYNode<F>, const D extends MutableEndpoint>(
+	familyToClusterMap: FamilyToClusterMap<F>,
+	deviceClass: Constructor<T>,
+	mapping: DeviceToClusterMap<T, D>
+) {
+	const map = {};
+	map[deviceClass.name] = mapping;
 
-	 return {...map,...familyToClusterMap};
+	return { ...map, ...familyToClusterMap };
 }
 export type SBAttributeMapping<SB extends SupportedBehaviors, D> = {
 	[K in keyof SB]: Partial<Record<any, DriversOf<D> | { driver: DriversOf<D>; converter?: string }>>;
@@ -140,7 +180,7 @@ export type SBCommandMapping<SB extends SupportedBehaviors, D> = {
 	[K in Capitalize<keyof SB>]?: SB[Uncapitalize<K>] extends { cluster: { commands } } ? Partial<Record<string, CommandsOf<D> | { driver: DriversOf<D>; converter?: string }>> : never;
 };
 type StringKeys<T> = Extract<keyof T, string>;
-type a = Clusters.ClusterType.CommandsOf<OnOffLightDevice['behaviors']['onOff']['cluster']>;
+type a = Cluster.ClusterType.CommandsOf<OnOffLightDevice['behaviors']['onOff']['cluster']>;
 type d = FamilyToClusterMap<Family.Insteon>;
 export type parameterMapping = {
 	[key: string]: { parameter: string; converter?: string };
@@ -192,16 +232,18 @@ export class MappingRegistry {
 		return m;
 	}
 
-	public static getMappingForBehavior<T extends ISYNode<any, any, any, any>, const B extends ClusterBehavior>(device: T, behavior: B): BehaviorMapping<B, T> {
+	public static getMappingForBehavior<T extends ISYNode<any, any, any, any>, const B extends ClusterBehavior>(device: T, behavior: B): ClusterMapping<B, T> {
 		//var m = MappingRegistry.getMapping(device);
 
 		//return m[behavior.cluster.name];
 		for (var m in MappingRegistry.getMapping(device).mapping) {
-			if (behavior.cluster.name === m) return MappingRegistry.getMapping(device).mapping[m] as unknown as BehaviorMapping<B, T>;
+			if (behavior.cluster.name === m) return MappingRegistry.getMapping(device).mapping[m] as unknown as ClusterMapping<B, T>;
 		}
 	}
 	//@ts-ignore
-	public static register<const T extends Family.Insteon | Family.ZWave | Family.ZigBee>(map: Partial<FamilyToClusterMap<T>> | { [x in PathsWithLimit<typeof Devices,1>]: DeviceToClusterMap<any, any> }) {
+	public static register<const T extends Family.Insteon | Family.ZWave | Family.ZigBee>(
+		map: Partial<FamilyToClusterMap<T>> | { [x in PathsWithLimit<typeof Devices, 1>]: DeviceToClusterMap<any, any> }
+	) {
 		if ('Family' in map) {
 			let regMap: Map<string, DeviceToClusterMap<any, any>>;
 			if (!MappingRegistry.map.has(map.Family)) {
@@ -256,16 +298,32 @@ var clusterMap = {
 		moveToColor: { command: DriverType.CustomControl1, parameters: { colorX: { parameter: 'colorX' }, colorY: { parameter: 'colorY' }, colorTemperature: { parameter: 'colorTemperature' } } }
 	}
 };
-/*const map: EndpointMapping<OnOffLightDevice, InsteonRelayDevice> = {
-	Identify: {},
-	OnOff: {
-		attributes: {
-			onOff: { driver: 'ST' }
+
+
+interface SimplyEndpointMapping<T extends ISYNode<Family, any, any, any>,K extends MutableEndpoint> extends SimplifyDeep<ISYtoMatterMapping<T,K>> {}
+
+/*
+const map = {
+	deviceType: DimmableLightDevice,
+	mapping: {
+
+		onOff: {
+			attributes: {
+			onOff: { driver: 'ST', converter: 'Percent.Boolean' },
+
+			},
+			commands: {
+				onWithTimedOff: { command: 'DON' },
+
+			}
 		},
-		commands: {
-			onWithTimedOff: { command: 'DON' }
+		levelControl: {
+			attributes: {
+
+
+			}
 		}
 	}
-};*/
-
+} as Mapping<Insteon.RelayLampNode, DimmableLightDevice>;
+*/
 // #endregion Variables (3)

package/src/Utils.ts

@@ -1,4 +1,3 @@
-
 import * as log4js from '@log4js-node/log4js-api';
 import winston, { Logger, format, type LeveledLogMethod, type LogMethod } from 'winston';
 
@@ -7,32 +6,26 @@ import { Category } from './Definitions/Global/Categories.js';
 
 //import { get } from 'http';
 import type { PackageJson } from '@npmcli/package-json';
+import type { Axios, AxiosRequestConfig } from 'axios';
 import { existsSync } from 'fs';
 import { readFile } from 'fs/promises';
 import path from 'path';
 import { Family } from './Definitions/index.js';
 import { EventType } from './Events/EventType.js';
-import type { Axios, AxiosRequestConfig } from 'axios';
 
 export type StringKeys<T> = Extract<keyof T, string>;
 
-export type PickOfType<T, U> = { [K in keyof T]: T[K] extends U ? (any extends T[K] ? never : K) : undefined }[keyof T];
+export type PickOfType<T, U> = {
+	[K in keyof T]: T[K] extends U ?
+		any extends T[K] ?
+			never
+		:	K
+	:	undefined;
+}[keyof 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;
+export type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
 
 export type Join<K, P> =
@@ -61,12 +54,12 @@ export type Remove<K extends string, T extends string> = K extends `${infer L}${
 
 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;
 }
 
 
+
 export type LogLevel = PickOfType<winston.Logger, LeveledLogMethod>;
 export type ValuesOf<TEnum extends number | string | boolean | bigint> = `${TEnum}` extends `${infer R extends number}` ? R : `${TEnum}`;
 
@@ -96,7 +89,7 @@ export function fromArray<T>(...value: T[]): MaybeArray<T> {
 
 export type BaseRequestConfig = Pick<AxiosRequestConfig, 'auth' | 'baseURL' | 'socketPath'>;
 
-export type ISYRequestConfig = Omit<AxiosRequestConfig, keyof BaseRequestConfig | 'method'>
+export type ISYRequestConfig = Omit<AxiosRequestConfig, keyof BaseRequestConfig | 'method'>;
 
 export function byteToPct(value) {
 	return Math.round((value * 100) / 255);
@@ -367,3 +360,13 @@ export function logStringify(obj: any, indent = 2) {
 	cache = null;
 	return retVal;
 }
+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;