@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/ts/integrations/deconz/deconz.classes.configflow.ts

@@ -1,39 +1,48 @@
 import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
+import { DeconzClient, DeconzRequestError } from './deconz.classes.client.js';
 import type { IDeconzConfig } from './deconz.types.js';
 
 export class DeconzConfigFlow implements IConfigFlow<IDeconzConfig> {
   public async start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IDeconzConfig>> {
     void contextArg;
+    const submit = async (valuesArg: Record<string, unknown>): Promise<IConfigFlowStep<IDeconzConfig>> => {
+      let client: DeconzClient | undefined;
+      try {
+        const host = valuesArg.host ?? candidateArg.host;
+        if (typeof host !== 'string' || !host) throw new Error('Host is required.');
+        if (valuesArg.apiKey !== undefined && typeof valuesArg.apiKey !== 'string') throw new Error('API key must be a string.');
+        if (valuesArg.port !== undefined && typeof valuesArg.port !== 'number') throw new Error('Port must be a number.');
+        const protocol = valuesArg.protocol ?? 'http';
+        if (protocol !== 'http' && protocol !== 'https') throw new Error('Protocol must be http or https.');
+        const config: IDeconzConfig = { host, port: valuesArg.port as number | undefined ?? candidateArg.port, protocol, apiKey: typeof valuesArg.apiKey === 'string' && valuesArg.apiKey ? valuesArg.apiKey : undefined };
+        client = new DeconzClient(config);
+        if (!config.apiKey) {
+          config.apiKey = await client.acquireApiKey();
+          await client.destroy();
+          client = new DeconzClient(config);
+        }
+        const snapshot = await client.getSnapshot();
+        if (candidateArg.id && snapshot.config?.bridgeid && candidateArg.id.replace(/[^a-f0-9]/gi, '').toUpperCase() !== snapshot.config.bridgeid.toUpperCase()) {
+          throw new Error('deCONZ gateway identity does not match discovery.');
+        }
+        config.bridgeId = snapshot.config?.bridgeid ?? snapshot.config?.uuid;
+        return { kind: 'done', title: 'deCONZ connected', config };
+      } catch (error) {
+        if (error instanceof DeconzRequestError && error.apiErrorType === 101) {
+          return { kind: 'wait', title: 'Unlock deCONZ', description: 'In Phoscon, open Gateway → Advanced → Authenticate app, then retry within 60 seconds.', submit: () => submit(valuesArg) };
+        }
+        return { kind: 'error', title: 'deCONZ connection failed', error: error instanceof Error ? error.message : 'deCONZ setup failed.' };
+      } finally { await client?.destroy(); }
+    };
     return {
-      kind: 'form',
-      title: 'Connect deCONZ Gateway',
-      description: 'Configure the local deCONZ REST API endpoint. Leave API key empty only if setup will use a snapshot fixture.',
+      kind: 'form', title: 'Connect deCONZ Gateway',
+      description: 'Provide a gateway API key, or leave it empty to pair after unlocking Authenticate app in Phoscon.',
       fields: [
         { name: 'host', label: 'Host', type: 'text', required: true },
         { name: 'port', label: 'Port', type: 'number' },
+        { name: 'protocol', label: 'Protocol', type: 'select', options: [{ label: 'HTTP', value: 'http' }, { label: 'HTTPS', value: 'https' }] },
         { name: 'apiKey', label: 'API key', type: 'password' },
-      ],
-      submit: async (valuesArg) => {
-        const host = String(valuesArg.host || candidateArg.host || '');
-        if (!host) {
-          return {
-            kind: 'error',
-            title: 'deCONZ configuration incomplete',
-            error: 'Host is required.',
-          };
-        }
-        return {
-          kind: 'done',
-          title: 'deCONZ configured',
-          config: {
-            bridgeId: candidateArg.id,
-            host,
-            port: typeof valuesArg.port === 'number' ? valuesArg.port : candidateArg.port || 80,
-            apiKey: valuesArg.apiKey ? String(valuesArg.apiKey) : undefined,
-            protocol: 'http',
-          },
-        };
-      },
+      ], submit,
     };
   }
 }

package/ts/integrations/deconz/deconz.classes.integration.ts

@@ -1,11 +1,11 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
-import type { IIntegrationEntity, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
+import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
 import { DeconzClient } from './deconz.classes.client.js';
 import { DeconzConfigFlow } from './deconz.classes.configflow.js';
 import { createDeconzDiscoveryDescriptor } from './deconz.discovery.js';
 import { DeconzMapper } from './deconz.mapper.js';
-import type { IDeconzConfig, IDeconzGroupActionPatch, IDeconzLightStatePatch, IDeconzSensorConfigPatch, IDeconzSensorStatePatch } from './deconz.types.js';
+import type { IDeconzConfig, IDeconzGroupActionPatch, IDeconzLightStatePatch, IDeconzSensorConfigPatch, IDeconzSensorStatePatch, IDeconzSnapshot } from './deconz.types.js';
 
 interface IDeconzServiceTarget {
   entity: IIntegrationEntity;
@@ -13,9 +13,12 @@ interface IDeconzServiceTarget {
   resourceId: string;
   stateKey?: string;
   configKey?: string;
+  snapshot: IDeconzSnapshot;
 }
 
 export class DeconzIntegration extends BaseIntegration<IDeconzConfig> {
+  private readonly clients = new Set<DeconzClient>();
+  private destroyed = false;
   public readonly domain = 'deconz';
   public readonly displayName = 'deCONZ';
   public readonly status = 'control-runtime' as const;
@@ -34,11 +37,23 @@ export class DeconzIntegration extends BaseIntegration<IDeconzConfig> {
   };
 
   public async setup(configArg: IDeconzConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime> {
-    void contextArg;
-    return new DeconzRuntime(new DeconzClient(configArg));
+    if (this.destroyed) throw new Error('deCONZ integration has been destroyed.');
+    const client = new DeconzClient(configArg, contextArg.abortSignal);
+    this.clients.add(client);
+    try {
+      await client.getSnapshot(contextArg.abortSignal);
+      if (this.destroyed || !client.isHealthy) throw new Error('deCONZ setup cancelled.');
+      const runtime = new DeconzRuntime(client, () => this.clients.delete(client));
+      return runtime;
+    } catch (error) { await client.destroy(); this.clients.delete(client); throw error; }
   }
 
-  public async destroy(): Promise<void> {}
+  public async destroy(): Promise<void> {
+    this.destroyed = true;
+    const results = await Promise.allSettled([...this.clients].map(async (clientArg) => { await clientArg.destroy(); this.clients.delete(clientArg); }));
+    const failures = results.filter((resultArg): resultArg is PromiseRejectedResult => resultArg.status === 'rejected');
+    if (failures.length) throw new AggregateError(failures.map((failureArg) => failureArg.reason), 'deCONZ runtime cleanup failed.');
+  }
 }
 
 export class HomeAssistantDeconzIntegration extends DeconzIntegration {}
@@ -46,21 +61,64 @@ export class HomeAssistantDeconzIntegration extends DeconzIntegration {}
 class DeconzRuntime implements IIntegrationRuntime {
   public domain = 'deconz';
 
-  constructor(private readonly client: DeconzClient) {}
+  constructor(private readonly client: DeconzClient, private readonly onDestroyed: () => void) {}
 
-  public async devices(): Promise<shxInterfaces.data.IDeviceDefinition[]> {
-    return DeconzMapper.toDevices(await this.client.getSnapshot());
+  public isHealthy(): boolean { return this.client.isHealthy; }
+
+  public async devices(abortSignalArg?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]> {
+    return DeconzMapper.toDevices(await this.client.getSnapshot(abortSignalArg));
   }
 
   public async entities(): Promise<IIntegrationEntity[]> {
     return DeconzMapper.toEntities(await this.client.getSnapshot());
   }
 
-  public async subscribe(handlerArg: Parameters<NonNullable<IIntegrationRuntime['subscribe']>>[0]): Promise<() => Promise<void>> {
-    return this.client.subscribeToEvents((eventArg) => handlerArg(DeconzMapper.toIntegrationEvent(eventArg)));
+  public async subscribe(handlerArg: Parameters<NonNullable<IIntegrationRuntime['subscribe']>>[0], abortSignalArg?: AbortSignal): Promise<() => Promise<void>> {
+    return this.client.subscribeToEvents((eventArg) => handlerArg(DeconzMapper.toIntegrationEvent(eventArg)), abortSignalArg, (errorArg) => handlerArg({ type: 'error', integrationDomain: 'deconz', data: { message: errorArg.message }, timestamp: Date.now() }));
+  }
+
+  public async writeFeature(requestArg: IDeviceFeatureWriteRequest, abortSignalArg?: AbortSignal): Promise<IServiceCallResult> {
+    if (!this.client.isHealthy) return { success: false, error: 'deCONZ runtime is not healthy.' };
+    const snapshot = await this.client.getSnapshot(abortSignalArg);
+    const matches = DeconzMapper.toDevices(snapshot).filter((deviceArg) => deviceArg.id === requestArg.device.id);
+    if (requestArg.device.integrationDomain !== this.domain || matches.length !== 1) return { success: false, error: 'deCONZ feature write requires one exact current device.' };
+    const device = matches[0];
+    const feature = device.features.find((featureArg) => featureArg.id === requestArg.feature.id && featureArg.capability === requestArg.feature.capability);
+    if (!device.online || !feature?.writable) return { success: false, error: 'deCONZ feature is unavailable or read-only.' };
+    const resource = device.metadata?.deconzResource;
+    const resourceId = device.metadata?.deconzId;
+    if (typeof resourceId !== 'string') return { success: false, error: 'Unknown deCONZ resource.' };
+    if (resource === 'lights' || resource === 'groups') {
+      const payload: IDeconzLightStatePatch = {};
+      if (feature.id === 'on' && typeof requestArg.value === 'boolean') payload.on = requestArg.value;
+      else if (feature.id === 'brightness' && this.inRange(requestArg.value, 0, 100)) { payload.bri = this.percentToBri(requestArg.value); payload.on = requestArg.value > 0; }
+      else if (feature.id === 'position' && resource === 'lights' && this.inRange(requestArg.value, 0, 100)) payload.lift = Math.round(100 - requestArg.value);
+      else return { success: false, error: 'Invalid deCONZ feature value.' };
+      if (resource === 'groups') await this.client.setGroupState(resourceId, payload, abortSignalArg);
+      else await this.client.setLightState(resourceId, payload, abortSignalArg);
+      return { success: true };
+    }
+    if (resource === 'sensors') {
+      const sensor = snapshot.sensors[resourceId];
+      if (feature.id === 'target_temperature') {
+        if (!this.inRange(requestArg.value, -327.68, 327.67)) return { success: false, error: 'Invalid deCONZ target temperature.' };
+        const key = sensor.config?.mode === 'cool' && sensor.config.coolsetpoint !== undefined ? 'coolsetpoint' : sensor.config?.heatsetpoint !== undefined ? 'heatsetpoint' : 'coolsetpoint';
+        await this.client.setSensorConfig(resourceId, { [key]: Math.round(requestArg.value * 100) }, abortSignalArg);
+        return { success: true };
+      }
+      const entity = DeconzMapper.toEntities(snapshot).find((entityArg) => entityArg.deviceId === device.id && entityArg.attributes?.deconzFeatureId === feature.id);
+      const key = entity?.attributes?.deconzStateKey;
+      if (!sensor.type?.startsWith('CLIP') || typeof key !== 'string' || !this.validSensorState(key, requestArg.value)) return { success: false, error: 'Invalid or read-only deCONZ sensor feature.' };
+      const multiplier = key === 'temperature' || key === 'humidity' ? 100 : key === 'consumption' || key === 'current' ? 1000 : 1;
+      const value = typeof requestArg.value === 'number' ? Math.round(requestArg.value * multiplier) : requestArg.value;
+      await this.client.setSensorState(resourceId, { [key]: value }, abortSignalArg);
+      return { success: true };
+    }
+    return { success: false, error: 'Unsupported deCONZ feature.' };
   }
 
   public async callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
+    if (!this.client.isHealthy) return { success: false, error: 'deCONZ runtime is not healthy.' };
     const target = await this.resolveTarget(requestArg);
     if (!target) {
       return { success: false, error: 'deCONZ service calls require a known target entityId or deviceId.' };
@@ -84,6 +142,7 @@ class DeconzRuntime implements IIntegrationRuntime {
 
   public async destroy(): Promise<void> {
     await this.client.destroy();
+    this.onDestroyed();
   }
 
   private async callLightService(targetArg: IDeconzServiceTarget, requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
@@ -138,7 +197,7 @@ class DeconzRuntime implements IIntegrationRuntime {
     }
     if (requestArg.service === 'set_position' || requestArg.service === 'set_percentage') {
       const position = this.numberFromData(requestArg.data, requestArg.service === 'set_position' ? ['position'] : ['percentage']);
-      if (position === undefined) {
+      if (position === undefined || !this.inRange(position, 0, 100)) {
         return { success: false, error: `deCONZ ${requestArg.service} requires a numeric position or percentage.` };
       }
       await this.client.setLightState(targetArg.resourceId, { lift: this.clamp(100 - position, 0, 100) });
@@ -166,9 +225,14 @@ class DeconzRuntime implements IIntegrationRuntime {
       return { success: false, error: 'deCONZ set_value requires a value.' };
     }
 
-    if (targetArg.configKey || this.isSensorConfigField(field)) {
+    const sensor = targetArg.snapshot.sensors[targetArg.resourceId];
+    if (this.isSensorConfigField(field)) {
+      const current = sensor.config?.[field];
+      if (current === undefined || typeof value !== typeof current || typeof value === 'number' && !Number.isFinite(value)) return { success: false, error: 'Invalid or unsupported deCONZ sensor configuration value.' };
+      if ((field === 'heatsetpoint' || field === 'coolsetpoint') && !this.inRange(value, -327.68, 327.67)) return { success: false, error: 'deCONZ target temperature is out of range.' };
       await this.client.setSensorConfig(targetArg.resourceId, { [field]: this.normalizeSensorConfigValue(field, value) } as IDeconzSensorConfigPatch);
     } else {
+      if (field !== targetArg.stateKey || !sensor.type?.startsWith('CLIP') || !this.validSensorState(field, value)) return { success: false, error: 'deCONZ state writes require a mapped writable CLIP field.' };
       await this.client.setSensorState(targetArg.resourceId, { [field]: value } as IDeconzSensorStatePatch);
     }
     return { success: true };
@@ -184,6 +248,10 @@ class DeconzRuntime implements IIntegrationRuntime {
       const brightnessPct = this.numberFromData(requestArg.data, ['brightness_pct', 'percentage']);
       const transition = this.numberFromData(requestArg.data, ['transition']);
       const colorTemp = this.numberFromData(requestArg.data, ['color_temp', 'color_temp_mired']);
+      if (brightness !== undefined && !this.inRange(brightness, 0, 255) || brightnessPct !== undefined && !this.inRange(brightnessPct, 0, 100) || transition !== undefined && !this.inRange(transition, 0, 6553.5) || colorTemp !== undefined && !this.inRange(colorTemp, 1, 65535)) return undefined;
+      for (const key of ['brightness', 'brightness_pct', 'percentage', 'transition', 'color_temp', 'color_temp_mired']) {
+        if (requestArg.data?.[key] !== undefined && this.numberFromData(requestArg.data, [key]) === undefined) return undefined;
+      }
       if (brightness !== undefined) {
         payload.bri = this.clamp(Math.round(brightness), 0, 255);
       } else if (brightnessPct !== undefined) {
@@ -195,14 +263,16 @@ class DeconzRuntime implements IIntegrationRuntime {
       if (colorTemp !== undefined) {
         payload.ct = Math.round(colorTemp);
       }
-      if (Array.isArray(requestArg.data?.xy_color)) {
-        payload.xy = requestArg.data.xy_color as number[];
+      if (requestArg.data?.xy_color !== undefined) {
+        const xy = requestArg.data.xy_color;
+        if (!Array.isArray(xy) || xy.length !== 2 || !xy.every((valueArg) => this.inRange(valueArg, 0, 1))) return undefined;
+        payload.xy = xy as number[];
       }
       return payload;
     }
     if (requestArg.service === 'set_percentage') {
       const percentage = this.numberFromData(requestArg.data, ['percentage']);
-      if (percentage === undefined) {
+      if (percentage === undefined || !this.inRange(percentage, 0, 100)) {
         return undefined;
       }
       return {
@@ -214,10 +284,11 @@ class DeconzRuntime implements IIntegrationRuntime {
   }
 
   private async resolveTarget(requestArg: IServiceCallRequest): Promise<IDeconzServiceTarget | undefined> {
-    const entities = DeconzMapper.toEntities(await this.client.getSnapshot());
-    const entity = entities.find((entityArg) => entityArg.id === requestArg.target.entityId)
-      || entities.find((entityArg) => entityArg.deviceId === requestArg.target.deviceId && entityArg.platform === requestArg.domain);
-    if (!entity) {
+    const snapshot = await this.client.getSnapshot();
+    const entities = DeconzMapper.toEntities(snapshot);
+    const matches = entities.filter((entityArg) => entityArg.platform === requestArg.domain && (!requestArg.target.entityId || entityArg.id === requestArg.target.entityId) && (!requestArg.target.deviceId || entityArg.deviceId === requestArg.target.deviceId));
+    const entity = matches[0];
+    if (!requestArg.target.entityId && !requestArg.target.deviceId || matches.length !== 1 || !entity?.available) {
       return undefined;
     }
 
@@ -232,6 +303,7 @@ class DeconzRuntime implements IIntegrationRuntime {
       resourceId,
       stateKey: typeof entity.attributes?.deconzStateKey === 'string' ? entity.attributes.deconzStateKey : undefined,
       configKey: typeof entity.attributes?.deconzConfigKey === 'string' ? entity.attributes.deconzConfigKey : undefined,
+      snapshot,
     };
   }
 
@@ -255,11 +327,11 @@ class DeconzRuntime implements IIntegrationRuntime {
   }
 
   private isSensorConfigField(fieldArg: string): boolean {
-    return new Set(['battery', 'coolsetpoint', 'fanmode', 'heatsetpoint', 'locked', 'mode', 'offset', 'on', 'preset', 'reachable', 'setvalve']).has(fieldArg);
+    return new Set(['coolsetpoint', 'fanmode', 'heatsetpoint', 'locked', 'mode', 'offset', 'on', 'preset', 'setvalve']).has(fieldArg);
   }
 
   private normalizeSensorConfigValue(fieldArg: string, valueArg: unknown): unknown {
-    if ((fieldArg === 'heatsetpoint' || fieldArg === 'coolsetpoint') && typeof valueArg === 'number' && Math.abs(valueArg) < 100) {
+    if ((fieldArg === 'heatsetpoint' || fieldArg === 'coolsetpoint') && typeof valueArg === 'number') {
       return Math.round(valueArg * 100);
     }
     return valueArg;
@@ -272,4 +344,15 @@ class DeconzRuntime implements IIntegrationRuntime {
   private clamp(valueArg: number, minArg: number, maxArg: number): number {
     return Math.min(maxArg, Math.max(minArg, valueArg));
   }
+
+  private inRange(valueArg: unknown, minArg: number, maxArg: number): valueArg is number {
+    return typeof valueArg === 'number' && Number.isFinite(valueArg) && valueArg >= minArg && valueArg <= maxArg;
+  }
+
+  private validSensorState(keyArg: string, valueArg: unknown): boolean {
+    if (new Set(['alarm', 'carbonmonoxide', 'fire', 'flag', 'open', 'presence', 'vibration', 'water']).has(keyArg)) return typeof valueArg === 'boolean';
+    if (keyArg === 'humidity') return this.inRange(valueArg, 0, 100);
+    if (keyArg === 'temperature') return this.inRange(valueArg, -327.68, 327.67);
+    return typeof valueArg === 'number' && Number.isFinite(valueArg) && Math.abs(valueArg) <= Number.MAX_SAFE_INTEGER;
+  }
 }

package/ts/integrations/deconz/deconz.mapper.ts

@@ -1,6 +1,7 @@
 import * as plugins from '../../plugins.js';
 import type { IIntegrationEntity, IIntegrationEvent } from '../../core/types.js';
 import type { IDeconzGroup, IDeconzLight, IDeconzSensor, IDeconzSnapshot, IDeconzWebsocketEvent } from './deconz.types.js';
+import { deconzWritableState } from './deconz.validation.js';
 
 interface IDeconzSensorEntityDescription {
   key: string;
@@ -45,7 +46,7 @@ const SENSOR_DESCRIPTIONS: IDeconzSensorEntityDescription[] = [
   { key: 'battery', platform: 'sensor', configKey: 'battery', nameSuffix: 'Battery', unit: '%', deviceClass: 'battery', value: (sensorArg) => sensorArg.config?.battery ?? sensorArg.state?.battery },
   { key: 'button_event', platform: 'sensor', stateKey: 'buttonevent', nameSuffix: 'Button Event', value: (sensorArg) => sensorArg.state?.buttonevent },
   { key: 'consumption', platform: 'sensor', stateKey: 'consumption', unit: 'kWh', deviceClass: 'energy', value: (sensorArg) => DeconzMapper.scaleConsumption(sensorArg.state?.consumption) },
-  { key: 'current', platform: 'sensor', stateKey: 'current', unit: 'A', value: (sensorArg) => sensorArg.state?.current },
+  { key: 'current', platform: 'sensor', stateKey: 'current', unit: 'A', value: (sensorArg) => DeconzMapper.scaleMilliamp(sensorArg.state?.current) },
   { key: 'humidity', platform: 'sensor', stateKey: 'humidity', unit: '%', deviceClass: 'humidity', value: (sensorArg) => DeconzMapper.scaleHundred(sensorArg.state?.humidity) },
   { key: 'light_level', platform: 'sensor', stateKey: 'lightlevel', unit: 'lx', deviceClass: 'illuminance', value: (sensorArg) => DeconzMapper.lightLevel(sensorArg) },
   { key: 'power', platform: 'sensor', stateKey: 'power', unit: 'W', deviceClass: 'power', value: (sensorArg) => sensorArg.state?.power },
@@ -98,6 +99,9 @@ export class DeconzMapper {
       devices.push(this.sensorToDevice(sensorId, sensor, updatedAt));
     }
 
+    if (snapshotArg.config?.rfconnected === false) {
+      return devices.map((deviceArg) => ({ ...deviceArg, online: false, state: deviceArg.state.map((stateArg) => stateArg.featureId === 'connectivity' ? { ...stateArg, value: 'offline' } : stateArg) }));
+    }
     return devices;
   }
 
@@ -134,7 +138,7 @@ export class DeconzMapper {
       }
     }
 
-    return entities;
+    return snapshotArg.config?.rfconnected === false ? entities.map((entityArg) => ({ ...entityArg, available: false })) : entities;
   }
 
   public static toIntegrationEvent(eventArg: IDeconzWebsocketEvent): IIntegrationEvent {
@@ -147,17 +151,19 @@ export class DeconzMapper {
   }
 
   public static scaleHundred(valueArg: unknown): number | undefined {
-    if (typeof valueArg !== 'number') {
-      return undefined;
-    }
-    return Math.abs(valueArg) > 200 ? valueArg / 100 : valueArg;
+    return this.scale(valueArg, 100);
   }
 
   public static scaleConsumption(valueArg: unknown): number | undefined {
-    if (typeof valueArg !== 'number') {
-      return undefined;
-    }
-    return Math.abs(valueArg) >= 1000 ? valueArg / 1000 : valueArg;
+    return this.scale(valueArg, 1000);
+  }
+
+  public static scaleMilliamp(valueArg: unknown): number | undefined {
+    return this.scale(valueArg, 1000);
+  }
+
+  private static scale(valueArg: unknown, divisorArg: number): number | undefined {
+    return typeof valueArg === 'number' && Number.isFinite(valueArg) ? valueArg / divisorArg : undefined;
   }
 
   public static lightLevel(sensorArg: IDeconzSensor): number | undefined {
@@ -204,6 +210,7 @@ export class DeconzMapper {
       features,
       state,
       metadata: {
+        deconzResource: 'lights',
         deconzId: lightIdArg,
         uniqueId: lightArg.uniqueid,
         type: lightArg.type,
@@ -236,6 +243,7 @@ export class DeconzMapper {
       ],
       state,
       metadata: {
+        deconzResource: 'groups',
         bridgeId: bridgeIdArg,
         deconzId: groupIdArg,
         lights: groupArg.lights,
@@ -253,7 +261,7 @@ export class DeconzMapper {
     ];
 
     if (this.isThermostat(sensorArg)) {
-      features.push({ id: 'target_temperature', capability: 'climate', name: 'Target Temperature', readable: true, writable: true, unit: 'C' });
+      features.push({ id: 'target_temperature', capability: 'climate', name: 'Target Temperature', readable: true, writable: typeof sensorArg.config?.heatsetpoint === 'number' || typeof sensorArg.config?.coolsetpoint === 'number', unit: 'C' });
       features.push({ id: 'current_temperature', capability: 'climate', name: 'Current Temperature', readable: true, writable: false, unit: 'C' });
       this.pushDeviceState(state, 'target_temperature', this.targetTemperature(sensorArg), updatedAtArg);
       this.pushDeviceState(state, 'current_temperature', this.scaleHundred(sensorArg.state?.temperature), updatedAtArg);
@@ -272,7 +280,7 @@ export class DeconzMapper {
         capability: 'sensor',
         name: this.entityName(sensorArg, description),
         readable: true,
-        writable: Boolean(sensorArg.type?.startsWith('CLIP') && description.stateKey),
+        writable: Boolean(description.stateKey && deconzWritableState(sensorArg.type, description.stateKey)),
         unit: description.unit,
       });
       this.pushDeviceState(state, description.key, description.platform === 'binary_sensor' ? Boolean(value) : value, updatedAtArg);
@@ -289,6 +297,7 @@ export class DeconzMapper {
       features,
       state,
       metadata: {
+        deconzResource: 'sensors',
         deconzId: sensorIdArg,
         uniqueId: sensorArg.uniqueid,
         type: sensorArg.type,
@@ -368,6 +377,7 @@ export class DeconzMapper {
         deconzId: sensorIdArg,
         deconzPath: descriptionArg.configKey ? `/sensors/${sensorIdArg}/config` : `/sensors/${sensorIdArg}/state`,
         deconzStateKey: descriptionArg.stateKey,
+        deconzFeatureId: descriptionArg.key,
         deconzConfigKey: descriptionArg.configKey,
         deviceClass: descriptionArg.deviceClass,
         unit: descriptionArg.unit,
@@ -489,7 +499,7 @@ export class DeconzMapper {
   }
 
   private static lightDeviceId(lightIdArg: string, lightArg: IDeconzLight): string {
-    return `deconz.light.${this.slug(this.serialFromUniqueId(lightArg.uniqueid) || lightArg.uniqueid || lightIdArg)}`;
+    return `deconz.light.${this.slug(lightArg.uniqueid || lightIdArg)}`;
   }
 
   private static groupDeviceId(bridgeIdArg: string, groupIdArg: string): string {
@@ -497,17 +507,13 @@ export class DeconzMapper {
   }
 
   private static sensorDeviceId(sensorIdArg: string, sensorArg: IDeconzSensor): string {
-    return `deconz.sensor.${this.slug(this.serialFromUniqueId(sensorArg.uniqueid) || sensorArg.uniqueid || sensorIdArg)}`;
+    return `deconz.sensor.${this.slug(sensorArg.uniqueid || sensorIdArg)}`;
   }
 
   private static bridgeId(snapshotArg: IDeconzSnapshot): string {
     return snapshotArg.config?.bridgeid || snapshotArg.config?.uuid || 'unknown';
   }
 
-  private static serialFromUniqueId(uniqueIdArg?: string): string | undefined {
-    return uniqueIdArg?.split('-')[0];
-  }
-
   private static entityId(platformArg: string, nameArg: string, usedIdsArg: Map<string, number>): string {
     const base = `${platformArg}.${this.slug(nameArg)}`;
     const count = usedIdsArg.get(base) || 0;

package/ts/integrations/deconz/deconz.types.ts

@@ -16,6 +16,7 @@ export interface IDeconzConfig {
   bridgeId?: string;
   websocketPort?: number;
   enableWebSocket?: boolean;
+  requestTimeoutMs?: number;
   snapshot?: IDeconzSnapshot;
 }
 
@@ -28,6 +29,7 @@ export interface IDeconzGatewayConfig {
   mac?: string;
   modelid?: string;
   name?: string;
+  rfconnected?: boolean;
   swversion?: string;
   uuid?: string;
   websocketnotifyall?: boolean;
@@ -198,11 +200,44 @@ export interface IDeconzSnapshot {
   [key: string]: unknown;
 }
 
-export interface IDeconzLightStatePatch extends Partial<IDeconzLightState> {}
+export interface IDeconzLightingStatePatch {
+  alert?: string;
+  bri?: number;
+  colorloopspeed?: number;
+  ct?: number;
+  effect?: string;
+  hue?: number;
+  on?: boolean;
+  sat?: number;
+  transitiontime?: number;
+  xy?: [number, number] | number[];
+}
+
+export interface IDeconzLightStatePatch extends IDeconzLightingStatePatch {
+  lift?: number | 'stop';
+  open?: boolean;
+  speed?: number;
+  stop?: boolean;
+  tilt?: number;
+}
 
-export interface IDeconzGroupActionPatch extends Partial<IDeconzLightState> {}
+export interface IDeconzGroupActionPatch extends IDeconzLightingStatePatch {
+  toggle?: boolean;
+}
 
-export interface IDeconzSensorConfigPatch extends Partial<IDeconzSensorConfig> {}
+export interface IDeconzSensorConfigPatch {
+  battery?: number;
+  coolsetpoint?: number;
+  fanmode?: 'off' | 'low' | 'medium' | 'high' | 'on' | 'auto' | 'smart';
+  heatsetpoint?: number;
+  locked?: boolean;
+  mode?: 'momentary' | 'rocker' | 'off' | 'auto' | 'cool' | 'heat' | 'emergency heating' | 'precooling' | 'fan only' | 'dry' | 'sleep';
+  offset?: number;
+  on?: boolean;
+  preset?: 'holiday' | 'auto' | 'manual' | 'comfort' | 'eco' | 'boost' | 'complex';
+  reachable?: boolean;
+  setvalve?: boolean;
+}
 
 export interface IDeconzSensorStatePatch extends Partial<IDeconzSensorState> {}