isy-nodejs 0.5.0-beta.9 → 1.0.1-alpha.0

package/src/Converters.ts

@@ -0,0 +1,87 @@
+import { UnitOfMeasure } from "./Definitions/Global/UOM.js";
+import { Converter, invert } from './Utils.js';
+
+let BooleanPercentage: Converter<boolean, number>;
+
+BooleanPercentage = {
+  to: (value: number): boolean => {
+    return value > 0;
+  },
+  from: (value: boolean): number => {
+    return value ? 100 : 0;
+  },
+};
+
+const StandardConverters : {
+    [x in `${keyof typeof UnitOfMeasure}`]?: { [y in `${keyof typeof UnitOfMeasure}`]?: Converter<any, any> };
+  }  = {
+  Boolean: {
+    LevelFrom0To255: {
+      from: (value: number) => value > 0,
+      to: (value: boolean) => (value ? 255 : 0),
+    },
+    Percent: BooleanPercentage,
+  },
+  Percent: {},
+  LevelFrom0To255: {
+    Percent: {
+      to: (value: number): number => {
+        return Math.round((value * 255) / 100);
+      },
+      from: (value: number): number => {
+        return Math.round((value * 100) / 255);
+      },
+    },
+  },
+};
+
+StandardConverters.Percent.LevelFrom0To255 = invert(StandardConverters.LevelFrom0To255.Percent);
+StandardConverters.LevelFrom0To255.Boolean = invert(StandardConverters.Boolean.LevelFrom0To255);
+
+export const ConverterRegistry = new Map<UnitOfMeasure, Map<UnitOfMeasure, Converter<any, any>>>();
+
+function registerConverters(){
+  for (const from in StandardConverters) {
+    for (const to in StandardConverters[from]) {
+      registerConverter(UnitOfMeasure[from], UnitOfMeasure[to], StandardConverters[from][to] as Converter<any, any>);
+    }
+  }
+}
+
+export function registerConverter(from: UnitOfMeasure, to: UnitOfMeasure, converter: Converter<any, any>)
+{
+  if (!ConverterRegistry.has(from)) {
+    ConverterRegistry.set(from, new Map());
+  }
+  ConverterRegistry.get(from).set(to, converter);
+}
+
+export namespace Converters {
+  export const Standard : typeof StandardConverters = StandardConverters;
+
+  export const Matter: { [x in `${keyof typeof UnitOfMeasure}`]?: { [y: string]: Converter<any, any> } } = {
+    LevelFrom0To255: {
+      LightingLevel: {
+        from: (value) => (value === 1 ? 0 : value === 254 ? 255 : value),
+        to: (value) => (value === 0 ? 1 : value === 255 ? 254 : value),
+      },
+    }
+  };
+
+  export function getConverter(from: UnitOfMeasure, to: UnitOfMeasure): Converter<any, any> {
+    if (!ConverterRegistry.has(from)) {
+      return null;
+    }
+    return ConverterRegistry.get(from).get(to);
+  }
+
+  export function convert<F,T>(from: UnitOfMeasure, to: UnitOfMeasure, value: F): T {
+    const converter = getConverter(from, to);
+    if (converter) {
+      return converter.to(value);
+    }
+    return null;
+  }
+}
+
+registerConverters();

package/src/Definitions/Brultech/generated/Error.ts

@@ -0,0 +1,4 @@
+export enum Error {
+    True = 0,
+    False = 1
+}

package/src/Definitions/Brultech/generated/index.ts

@@ -0,0 +1 @@
+export * from "./Error.js";

package/src/Definitions/Brultech/index.ts

@@ -0,0 +1 @@
+export * from "./generated/index.js";

package/src/Definitions/Generic/Error.ts

@@ -0,0 +1,4 @@
+export enum Error {
+    True = 0,
+    False = 1
+}

package/src/Definitions/Generic/index.ts

@@ -0,0 +1 @@
+export * from './Error.js';

package/src/Definitions/Global/Categories.ts

@@ -0,0 +1,19 @@
+export enum Category {
+  Controller = 0,
+  DimmableControl = 1,
+  RelayControl = 2,
+  NetworkBridge = 3,
+  IrrigationControl = 4,
+  ClimateControl = 5,
+  PoolControl = 6,
+  SensorActuator = 7,
+  HomeEntertainment = 8,
+  EnergyManagement = 9,
+  ApplianceControl = 10,
+  WindowShadeControl = 14,
+  AccessControl = 15,
+  SecurityHealthSafety = 16,
+  A10X10 = 113,
+  Virtual = 127,
+  Unknown = 254,
+}

package/src/Definitions/Global/Commands.ts

@@ -0,0 +1,35 @@
+import { TimeFormatLocalization } from '@project-chip/matter.js/cluster';
+import type { Identity, Merge, UnionToIntersection } from '@project-chip/matter.js/util';
+import type { Sign } from 'crypto';
+
+export namespace Command {
+
+    export type Signature<F extends {name: string} = CallableFunction, L extends string = string,N extends string = string> = F & {label: L, name: N };
+
+    export type Signatures<C extends string> = {[K in C]: Signature<(...args: any[]) => Promise<Boolean>, string, string>};
+
+    export type NoExtraKeys<U> = U extends infer F ? F : never;
+
+    export type NoExtend<F,T> = F extends T ? F : never;
+
+    export type For<N extends string, L extends string, T> = T extends Signature<infer F, L, N> ? F : T;
+
+    //type test2 = ForAll<Signatures<"BEEP">>
+
+    //extends CallableFunction ? Omit<T, "label"| "name"> | T : never;
+    type test = For<"beep","Beep",Commands["BEEP"]>
+
+    //type test2 = keyof Commands["BEEP"]
+
+    export type ForAll<T extends Signatures<any>> = {
+      [K in keyof T]: For<T[K]["name"],T[K]["label"],T[K]>
+
+    };
+
+   type Commands = {
+    BEEP: ((value: number) => Promise<boolean>) & {label: "Beep", name: "beep"};
+    BL:((value: number) => Promise<boolean>) & {label: "Backlight", name: "backlight"};
+    WDU: (() => Promise<boolean>) & {label: "Backlight", name: "backlight"};
+   }
+
+};

package/src/Definitions/Global/Drivers.ts

@@ -0,0 +1,490 @@
+import EventEmitter from 'events';
+import { isBoxedPrimitive } from 'util/types';
+import type { ISYNode } from '../../ISYNode.js';
+import { UnitOfMeasure } from './UOM.js';
+
+import { KeyType } from '@project-chip/matter.js/crypto';
+import type { TlvNumberSchema } from '@project-chip/matter.js/tlv';
+import type { Identity, MaybePromise, UnionToIntersection } from '@project-chip/matter.js/util';
+import exp from 'constants';
+import { init } from 'homebridge';
+import { server } from 'typescript';
+import type { ISYDeviceNode } from '../../Devices/ISYDeviceNode.js';
+import type { DriverState } from '../../Model/DriverState.js';
+import type { Converter, StringKeys } from '../../Utils.js';
+import type { Family } from './Families.js';
+
+export enum DriverType {
+	AccelerationXAxis = 'ACCX',
+	AccelerationYAxis = 'ACCY',
+	AccelerationZAxis = 'ACCZ',
+	AirFlow = 'AIRFLOW',
+	AirQualityIndex = 'AQI',
+	Alarm = 'ALARM',
+	AnglePosition = 'ANGLPOS',
+	AtmosphericPressure = 'ATMPRES',
+	AutoDRProcessingState = 'ADRPST',
+	Awake = 'AWAKE',
+	BarometricPressure = 'BARPRES',
+	BatteryLevel = 'BATLVL',
+	Beep = 'BEEP',
+	BloodPressureDiastolic = 'BPDIA',
+	BloodPressureSystolic = 'BPSYS',
+	BodyMassIndex = 'BMI',
+	BoneMass = 'BONEM',
+	Brighten = 'BRT',
+	CarbonMonoxideLevel = 'CO',
+	CO2Level = 'CO2LVL',
+	ControllerAction = 'CTL',
+	CoolSetpoint = 'CLISPC',
+	CurrentCurrent = 'CC',
+	CurrentPowerUsed = 'CPW',
+	CurrentTemperature = 'CLITEMP',
+	CurrentVoltage = 'CV',
+	CustomControl0 = 'GV0',
+	CustomControl1 = 'GV1',
+	CustomControl2 = 'GV2',
+	CustomControl3 = 'GV3',
+
+	CustomControl4 = 'GV4',
+	CustomControl5 = 'GV5',
+	CustomControl6 = 'GV6',
+	CustomControl7 = 'GV7',
+	CustomControl8 = 'GV8',
+	CustomControl9 = 'GV9',
+	CustomControl10 = 'GV10',
+	CustomControl11 = 'GV11',
+	CustomControl12 = 'GV12',
+	CustomControl13 = 'GV13',
+	CustomControl14 = 'GV14',
+	CustomControl15 = 'GV15',
+	CustomControl16 = 'GV16',
+	CustomControl17 = 'GV17',
+	CustomControl18 = 'GV18',
+	CustomControl19 = 'GV19',
+	CustomControl20 = 'GV20',
+	CustomControl21 = 'GV21',
+	CustomControl22 = 'GV22',
+	CustomControl23 = 'GV23',
+	CustomControl24 = 'GV24',
+	CustomControl25 = 'GV25',
+	CustomControl26 = 'GV26',
+	CustomControl27 = 'GV27',
+	CustomControl28 = 'GV28',
+	CustomControl29 = 'GV29',
+	CustomControl30 = 'GV30',
+	Delay = 'DELAY',
+	DewPoint = 'DEWPT',
+	DeviceIsBusy = 'BUSY',
+	DeviceSecureMode = 'SECMD',
+	Dim = 'DIM',
+	Distance = 'DISTANC',
+	DomesticHotWaterTemperature = 'WATERTD',
+	Duration = 'DUR',
+	ElectricalConductivity = 'ELECCON',
+	ElectricalResistivity = 'ELECRES',
+	EnergyMode = 'CLIEMD',
+	Error = 'ERR',
+	Evapotranspiration = 'ETO',
+	ExhaustTemperature = 'TEMPEXH',
+	FadeDown = 'FDDOWN',
+	FadeStop = 'FDSTOP',
+	FadeUp = 'FDUP',
+	FanRunningState = 'CLIFRS',
+	FanSetting = 'CLIFS',
+	FanSettingOverride = 'CLIFSO',
+	FastOff = 'DFOF',
+	FastOn = 'DFON',
+	FormaldehydeCH2OLevel = 'CH20',
+	Frequency = 'FREQ',
+	GeneralPurposeValue = 'GPV',
+	GenericVolume = 'GVOL',
+	Gust = 'GUST',
+	HeatCoolState = 'CLIHCS',
+	HeatIndex = 'HEATIX',
+	HeatSetpoint = 'CLISPH',
+	Hail = 'HAIL',
+	HeartRate = 'HR',
+	Humidity = 'CLIHUM',
+	Luminance = 'LUMIN',
+	MethaneDensity = 'METHANE',
+	Mode = 'MODE',
+	Moisture = 'MOIST',
+	MoonPhase = 'MOON',
+	MuscleMass = 'MUSCLEM',
+	Off = 'DOF',
+	Off3KeyPresses = 'DOF3',
+	Off4KeyPresses = 'DOF4',
+	Off5KeyPresses = 'DOF5',
+	On = 'DON',
+	On3KeyPresses = 'DON3',
+	On4KeyPresses = 'DON4',
+	On5KeyPresses = 'DON5',
+	OnLevel = 'OL',
+	Ozone = 'OZONE',
+	ParticulateMatter10 = 'PM10',
+	ParticulateMatter25 = 'PM25',
+	PercentChanceOfPrecipitation = 'POP',
+	PolarizedPowerUsed = 'PPW',
+	PowerFactor = 'PF',
+	Precipitation = 'PRECIP',
+	PulseCount = 'PULSCNT',
+	QueryDevice = 'QUERY',
+	RadonConcentration = 'RADON',
+	RainRate = 'RAINRT',
+	RampRate = 'RR',
+	RelativeModulationLevel = 'RELMOD',
+	ResetValues = 'RESET',
+	RespiratoryRate = 'RESPR',
+	RFSignalStrength = 'RFSS',
+	Rotation = 'ROTATE',
+	ScheduleMode = 'CLISMD',
+	SeismicIntensity = 'SEISINT',
+	SeismicMagnitude = 'SEISMAG',
+	SmokeDensity = 'SMOKED',
+	SoilHumidity = 'SOILH',
+	SoilReactivity = 'SOILR',
+	SoilSalinity = 'SOILS',
+	SoilTemperature = 'SOILT',
+	SolarRadiation = 'SOLRAD',
+	SoundVolume = 'SVOL',
+	Speed = 'SPEED',
+	Status = 'ST',
+	TankCapacity = 'TANKCAP',
+	TheUserAccessCodeThatAssociatedWithTheMostRecentAlarm = 'USRNUM',
+	ThermostatMode = 'CLIMD',
+	TideLevel = 'TIDELVL',
+	Time = 'TIME',
+	TimeRemaining = 'TIMEREM',
+	TotalBodyWater = 'TBW',
+	TotalPowerUsed = 'TPW',
+	Ultraviolet = 'UV',
+	ValidUserAccessCodeEntered = 'UAC',
+	Velocity = 'SPEED',
+	VOCLevel = 'VOCLVL',
+	WaterFlow = 'WATERF',
+	WaterPressure = 'WATERP',
+	WaterTemperature = 'WATERT',
+	WaterVolume = 'WVOL',
+	Weight = 'WEIGHT',
+	WindChill = 'WINDCH',
+	WindDirection = 'WINDDIR',
+	BoilerWaterTemperature = 'WATERTB',
+	OutsideTemperature = 'TEMPOUT'
+}
+
+type a = keyof typeof DriverType;
+
+type EnumFromLabel<L extends keyof N, N> = N[L];
+
+type DriverTypeFromName<N extends keyof typeof DriverType> = EnumFromLabel<N, typeof DriverType>;
+type x = DriverTypeFromName<'Status' | 'SoilTemperature'>;
+
+//export type DriverLabel<T extends DriverType> = ReturnType>LabelMap.get>
+
+export type EnumLiteral<T> =
+	T extends string ? `${T}`
+	: T extends boolean ?
+		T extends true ?
+			true
+		:	false
+	:	T;
+
+type y = EnumLiteral<DriverType.Status>;
+
+type z = EnumLiteral<DriverType.Status | DriverType.Precipitation>;
+
+type T = DriverTypeFromName<keyof typeof DriverType>;
+
+//type Driver<D extends DriverType> = D extends D[0] | infer K extends DriverType ? D[0] | DriverLabels<K> : never;
+
+type s = EnumLiteral<{ 100: true; 200: false }>;
+
+export type DriverList<D> =
+	D extends DriverType ? { [K in D]?: Driver<K, any, any> } & { add(driver: Driver<D, any, any>): void }
+	: D extends EnumLiteral<infer R extends DriverType> ? { [K in R]?: Driver<R, any, any> } & { add(driver: Driver<R, any, any>): void }
+	: {}; //& { [N in keyof typeof DriverType]?: Driver<DriverTypeFromName<N>> };
+
+type KeyOrValue<K, D> =
+	K extends D ? D
+	: K extends keyof D ? D[K]
+	: never;
+
+const LabelMap = new Map<DriverType, keyof typeof DriverType>(Object.entries(DriverType).map(([a, b]) => [b, a]) as any);
+
+///onst DriverNames = Object.entries(DriverType).(a)=>[a[1],a[0]]) as [DriverType,(keyof typeof DriverType)][];
+type DriverListType<D extends DriverType> = Identity<DriverList<D>>;
+
+export class Drivers<D extends DriverType> {
+	// #region Properties (1)
+
+	public DriverHandler: ProxyHandler<Drivers<D>> = {
+		set(target, p: DriverType | keyof typeof DriverType, newValue, receiver) {
+			if (p in target) {
+				if (p in DriverType) {
+					target[p] = newValue;
+					target[LabelMap.get(p as DriverType)] = newValue;
+					return true;
+				} else if (typeof p === 'string' && p in LabelMap.values()) {
+					target[DriverType[p]] = newValue;
+					target[p] = newValue;
+					return true;
+				}
+				return true;
+			}
+			return false;
+		},
+		get(target, p: DriverType | keyof typeof DriverType, receiver) {
+			if (p in target) {
+				return target[p];
+			}
+			return undefined;
+		}
+	};
+
+	// #endregion Properties (1)
+
+	// #region Constructors (1)
+
+	constructor() {
+		return new Proxy(this, this.DriverHandler);
+	}
+
+	// #endregion Constructors (1)
+
+	// #region Public Methods (1)
+
+	public add<K extends D>(driver: Driver<K, any, any>) {
+		(this as unknown)[driver.id] = driver;
+		(this as unknown)[LabelMap.get(driver.id)] = driver;
+	}
+
+	// #endregion Public Methods (1)
+}
+
+export interface Driver<
+	D extends DriverType | EnumLiteral<DriverType> | `${string}.${EnumLiteral<DriverType>}` | string,
+	U extends UnitOfMeasure,
+	T = number,
+	SU extends UnitOfMeasure = U,
+	ST = number,
+	N = string,
+	L = string
+> {
+	// #region Properties (8)
+
+	readonly value: T;
+
+	id: D;
+	label: L;
+	name: N;
+	query: () => Promise<DriverState>;
+	serverUom?: SU;
+	state: {
+		initial: boolean;
+		value: T;
+		formattedValue?: any;
+		pendingValue: T;
+	};
+	uom: U;
+
+	// #endregion Properties (8)
+
+	// #region Public Methods (2)
+
+	apply(state: DriverState, notify?: boolean): boolean;
+	patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number): boolean;
+
+	// #endregion Public Methods (2)
+//override on('change', listener: (value: any) => void): this;
+}
+
+export interface StatelessDriver<
+	D extends DriverType | EnumLiteral<DriverType> | `${string}.${EnumLiteral<DriverType>}` | string,
+	U extends UnitOfMeasure,
+	T = number,
+	SU extends UnitOfMeasure = U,
+	N = string,
+	L = string
+> {
+	// #region Properties (9)
+
+	readonly value: Promise<T>;
+
+	id: D;
+	label: L;
+	name: N;
+	query: () => Promise<DriverState>;
+	serverUom?: SU;
+	state: {
+		initial: boolean;
+		value: T;
+		formattedValue?: any;
+		pendingValue: T;
+	};
+	stateless: true;
+	uom: U;
+
+	// #endregion Properties (9)
+//override on('change', listener: (value: any) => void): this;
+}
+
+export function isStateless(x: any): x is StatelessDriver<any, any, any> {
+	return x.stateless;
+}
+
+export function isTrue(x: true | false): x is true {
+	return x;
+}
+
+export type DriverTypeLiteral = EnumLiteral<DriverType>;
+
+
+export type EnumWithLiteral<D extends string | bigint | number | boolean> = D | EnumLiteral<D>;
+export namespace Driver {
+	export type Signature<U extends UnitOfMeasure = UnitOfMeasure, V = any, SU = U, N = string, L = N> = { uom: U; value: V; name: N; label: L; serverUom?: SU };
+
+	export type Signatures<D> = UnionToIntersection<
+		D extends string ? { [K in D]: Signature<UnitOfMeasure, any, UnitOfMeasure, string, string> }
+		: D extends { [K in keyof D]: Signature } ? D
+		: never
+	>;
+
+	///D extends (infer R extends string | infer K extends {[L in keyof K]: Signature}) ? {[J in R & string]: Signature} & K : D extends string ? { [K in D]: Signature } : D extends {[K in keyof D]: Signature} ? D : never;
+
+	type test = Signatures<DriverType.Status | { ERR: Signature; BUSY: Signature } | { ERR: Signature; BUSY: Signature } | { ERR: Signature; BUSY: Signature }>;
+
+	type Drivers = {
+		ST?: {
+			uom: UnitOfMeasure.Percent;
+			value: number;
+			name: 'status';
+			label: 'Status';
+		};
+		ERR?: {
+			uom: UnitOfMeasure.Index;
+			value: number;
+			name: 'responding';
+			label: 'Responding';
+		};
+	};
+
+	export type For<D extends string, T, S extends boolean = false> = T extends Signature<infer U, infer V, infer SU, infer N, infer L> ? StatelessOrStateful<D, U, V, N, L, S> : never;
+
+	export type ForAll<T, S extends boolean = false> = {
+		[K in StringKeys<T>]: T[K] extends Signature<UnitOfMeasure, any, UnitOfMeasure, string, string> ? For<K, T[K], S> : never;
+	};
+
+	type test2 = ForAll<Drivers>;
+
+	export type Type = DriverType;
+	export type Literal = EnumLiteral<DriverType>;
+	export type LiteralWithExtensions = Literal | `${string}.${Literal}`;
+	export type LiteralWithType = EnumWithLiteral<DriverType>;
+	type StatelessOrStateful<D extends string, U extends UnitOfMeasure, T = number, N = string, L = string, S extends boolean = false> =
+		S extends true ? StatelessDriver<D, U, T, U, N, L> : Driver<D, U, T, U, N, L>;
+
+	export function create<D extends Literal, U extends UnitOfMeasure, T = number, L extends string = string, N extends string = string, S extends boolean = false>(
+		driver: EnumWithLiteral<D>,
+
+		node?: ISYNode<Family, any, any, any>,
+		initState?: DriverState,
+		driverSignature?: { uom: U; label: L; name: N },
+		stateless?: S,
+		converter?: Converter<any, T>
+	): StatelessOrStateful<D, U, T, N, L, S> {
+		const query = async () => {
+			return await node.readProperty(driver as D);
+		};
+
+		if (isTrue(stateless)) {
+			return {
+				id: driver as D,
+				stateless: true,
+				uom: initState.uom as U,
+				state: {
+					initial: true,
+					value: node.convertFrom(initState?.value, initState?.uom, driver as D) as T,
+					formattedValue: initState.formatted,
+					pendingValue: null
+				},
+				query,
+				get value() {
+					return query().then((p) => p.value) as Promise<T>;
+				},
+				name: initState.name ?? driverSignature.name ?? driverSignature.label ?? driver,
+				label: driverSignature.label ?? driver
+			} as unknown as StatelessOrStateful<D, U, T, N, L, typeof stateless>;
+		}
+		var c = {
+			id: driver as D,
+			uom: driverSignature?.uom as U,
+			serverUom: initState?.uom != driverSignature?.uom ? initState?.uom : undefined,
+			state: {
+				initial: true,
+				value:
+					initState ?
+						converter ? converter.from(initState.value)
+						:	(node.convertFrom(initState?.value, initState?.uom, driver as D) as T)
+					:	null,
+				formattedValue: initState ? initState.formatted : null,
+				pendingValue: null
+			},
+			async query() {
+				let s = await query();
+				this.state.value = converter ? converter.from(s.value) : node.convertFrom(s.value, s.uom, driver as D);
+				this.state.formattedValue = s.formatted;
+				return s;
+			},
+			apply(state: DriverState, notify = false) {
+				let previousValue = this.state.value;
+				this.state.value = converter ? converter.from(state.value) : node.convertFrom(state.value, state.uom, driver as D);
+				this.state.formattedValue = state.formatted;
+				if (previousValue == this.state.value) {
+					return false;
+				}
+				if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, this.state.formattedValue);
+				return true;
+			},
+			patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify = false) {
+				let previousValue = this.state.value;
+
+				this.state.formattedValue = formattedValue;
+				if (uom != this.uom) {
+					this.serverUom = uom;
+					this.state.value = converter ? converter.from(value) : node.convertFrom(value, uom, driver as D);
+				}
+				if (previousValue == this.state.value) {
+					return false;
+				}
+				if (notify) node.events.emit(`${this.name}Changed`, driver as D, value, previousValue, formattedValue);
+				return true;
+			},
+			get value() {
+				return c.state.value;
+			},
+			name: initState?.name ?? driverSignature?.name ?? driver,
+			label: driverSignature?.label ?? driver
+		};
+		//  node.on('PropertyChanged', (propertyName, newValue, oldValue, formattedValue) => {
+		//     if (propertyName === driver) {
+		//         c.state.initial = false;
+		//         c.state.value = node.convertFrom(newValue,c.uom,driver as D);
+		//         c.state.formattedValue = formattedValue;
+		//     }
+
+		//});
+		return c as unknown as StatelessOrStateful<D, U, T, N, L, typeof stateless>;
+	}
+}
+
+// type EnumValues2<T extends string> = T extends { [Type in keyof T]: string } ? T extenDrivers[0] |  : never;
+
+// type EnumValues<T> = T extends { [x in keyof T]: string }
+//   ? T extends string | infer K extends string
+//     ? [keyof T][0] | EnumValues<K>
+//     : never
+//   : T;
+
+// type Driver = EnumValues2<Drivers>
+// let x : Driver = "ACvCX"