@smarthome.exchange/integrations 2.0.0 → 3.0.0

package/ts/integrations/deconz/deconz.validation.ts

@@ -1,4 +1,144 @@
-import type { IDeconzConfig, IDeconzGatewayConfig, IDeconzGroupActionPatch, IDeconzLightingStatePatch, IDeconzLightStatePatch, IDeconzSensorConfigPatch, IDeconzSnapshot, IDeconzWebsocketEvent } from './deconz.types.js';
+import type { IDeconzConfig, IDeconzGatewayConfig, IDeconzGroupActionPatch, IDeconzIntegrationOptions, IDeconzLightingStatePatch, IDeconzLightStatePatch, IDeconzSensorConfigPatch, IDeconzSnapshot, IDeconzWebsocketEvent } from './deconz.types.js';
+
+export function deconzData(valueArg: unknown, allowedArg: readonly string[]): Record<string, unknown> {
+  if (!valueArg || typeof valueArg !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(valueArg) as object | null)) throw new TypeError('deCONZ requires a plain data object.');
+  const result: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+  for (const key of Reflect.ownKeys(valueArg)) {
+    const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+    if (typeof key !== 'string' || !allowedArg.includes(key) || !descriptor?.enumerable || !('value' in descriptor)) throw new TypeError('Unsupported deCONZ field or accessor.');
+    result[key] = descriptor.value as unknown;
+  }
+  return result;
+}
+
+export function deconzText(valueArg: unknown, nameArg: string, maximumArg = 256): string {
+  if (typeof valueArg !== 'string' || !valueArg || valueArg.length > maximumArg || valueArg.trim() !== valueArg || /[\p{Cc}\p{Cs}]/u.test(valueArg)) throw new TypeError(`Invalid deCONZ ${nameArg}.`);
+  return valueArg;
+}
+
+export function deconzBridgeId(valueArg: unknown): string {
+  const text = deconzText(valueArg, 'selected bridge identity');
+  if (!/^[a-f0-9]{16}$/i.test(text) && !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(text)) throw new TypeError('Invalid deCONZ selected bridge identity.');
+  return text.toLowerCase();
+}
+
+export function normalizeDeconzConfig(valueArg: unknown): Readonly<IDeconzConfig> {
+  const value = deconzData(valueArg, ['homeId', 'host', 'port', 'protocol', 'bridgeId', 'credentialReference', 'enableWebSocket', 'requestTimeoutMs']);
+  const homeId = deconzText(value.homeId, 'configuration home');
+  const credentialReference = deconzText(value.credentialReference, 'credential reference');
+  if (encodeURIComponent(credentialReference).length > 900) throw new TypeError('deCONZ credential reference is too long.');
+  const config: IDeconzConfig = { homeId, host: deconzText(value.host, 'host'), credentialReference, bridgeId: deconzBridgeId(value.bridgeId) };
+  if (value.protocol !== undefined) {
+    if (value.protocol !== 'http' && value.protocol !== 'https') throw new TypeError('Invalid deCONZ protocol.');
+    config.protocol = value.protocol;
+  }
+  if (value.port !== undefined) config.port = deconzPort(value.port);
+  if (value.enableWebSocket !== undefined) {
+    if (typeof value.enableWebSocket !== 'boolean') throw new TypeError('Invalid deCONZ WebSocket setting.');
+    config.enableWebSocket = value.enableWebSocket;
+  }
+  const timeout = value.requestTimeoutMs ?? 15000;
+  if (typeof timeout !== 'number' || !Number.isInteger(timeout) || timeout < 1 || timeout > 120000) throw new TypeError('Invalid deCONZ request deadline.');
+  config.requestTimeoutMs = timeout;
+  deconzEndpoint(config);
+  return Object.freeze(config);
+}
+
+function method(valueArg: unknown, keyArg: string): ((...argsArg: never[]) => unknown) | undefined {
+  if (!valueArg || typeof valueArg !== 'object') throw new TypeError('Invalid deCONZ credential provider.');
+  let target: object | null = valueArg;
+  for (let depth = 0; target && depth < 16; depth++) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, keyArg);
+    if (descriptor) {
+      if (!('value' in descriptor) || typeof descriptor.value !== 'function') throw new TypeError('deCONZ provider requires data methods.');
+      return Function.prototype.bind.call(descriptor.value, valueArg) as (...argsArg: never[]) => unknown;
+    }
+    target = Object.getPrototypeOf(target) as object | null;
+  }
+  return undefined;
+}
+
+export function captureDeconzOptions(valueArg: IDeconzIntegrationOptions = {}): Readonly<IDeconzIntegrationOptions> {
+  const value = deconzData(valueArg, ['homeId', 'capacity', 'credentialProvider', 'controlPermissions', 'db', 'keyProvider']);
+  const result: IDeconzIntegrationOptions = {};
+  if (value.homeId !== undefined) Object.assign(result, { homeId: deconzText(value.homeId, 'constructor home') });
+  if (value.capacity !== undefined) {
+    if (typeof value.capacity !== 'number' || !Number.isSafeInteger(value.capacity) || value.capacity < 1 || value.capacity > 16) throw new TypeError('deCONZ capacity must be from 1 through 16.');
+    Object.assign(result, { capacity: value.capacity });
+  }
+  if (value.credentialProvider !== undefined) {
+    const resolve = method(value.credentialProvider, 'resolve');
+    const create = method(value.credentialProvider, 'create');
+    if (!resolve) throw new TypeError('deCONZ credential provider must resolve references.');
+    Object.assign(result, { credentialProvider: Object.freeze({ resolve, ...(create ? { create } : {}) }) });
+  }
+  if (value.controlPermissions !== undefined) {
+    if (!Array.isArray(value.controlPermissions) || value.controlPermissions.length > 128) throw new TypeError('Invalid deCONZ control permissions.');
+    const permissions = dataArray(value.controlPermissions).map((permissionArg: unknown) => {
+      const permission = deconzData(permissionArg, ['resource', 'resourceId', 'fields']);
+      if (typeof permission.resource !== 'string' || !['config', 'lights', 'groups', 'sensors', 'scenes'].includes(permission.resource)) throw new TypeError('Invalid deCONZ permission resource.');
+      const resourceId = deconzText(permission.resourceId, 'permission resource', 128);
+      if (!Array.isArray(permission.fields) || !permission.fields.length || permission.fields.length > 32) throw new TypeError('Invalid deCONZ permission fields.');
+      const fields = dataArray(permission.fields).map((fieldArg: unknown) => deconzText(fieldArg, 'permission field', 64));
+      return Object.freeze({ resource: permission.resource, resourceId, fields: Object.freeze(fields) });
+    });
+    Object.assign(result, { controlPermissions: Object.freeze(permissions) });
+  }
+  if (value.db !== undefined) Object.assign(result, { db: value.db });
+  if (value.keyProvider !== undefined) {
+    const currentKey = method(value.keyProvider, 'currentKey');
+    const keyForId = method(value.keyProvider, 'keyForId');
+    if (!currentKey || !keyForId) throw new TypeError('deCONZ encrypted storage requires data-method key providers.');
+    Object.assign(result, { keyProvider: Object.freeze({ currentKey, keyForId }) });
+  }
+  if (Boolean(value.db) !== Boolean(value.keyProvider)) throw new TypeError('deCONZ owned encrypted storage requires both database and key provider.');
+  return Object.freeze(result);
+}
+
+function dataArray(valueArg: unknown[]): unknown[] {
+  if (Reflect.ownKeys(valueArg).some((key) => key !== 'length' && (typeof key !== 'string' || !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= valueArg.length))) throw new TypeError('deCONZ arrays require dense data fields.');
+  return Array.from({ length: valueArg.length }, (_, index) => { const descriptor = Object.getOwnPropertyDescriptor(valueArg, String(index)); if (!descriptor?.enumerable || !('value' in descriptor)) throw new TypeError('deCONZ arrays require dense data fields.'); return descriptor.value as unknown; });
+}
+
+export function deconzCurrentPatch(snapshotArg: IDeconzSnapshot, resourceArg: 'lights' | 'groups' | 'sensors', idArg: string, sectionArg: 'state' | 'action' | 'config', patchArg: Record<string, unknown>): void {
+  if (snapshotArg.config?.rfconnected === false) throw new Error('deCONZ Zigbee network is unavailable.');
+  const item = snapshotArg[resourceArg][idArg];
+  if (!item) throw new Error('deCONZ control requires an exact current resource.');
+  const state = resourceArg === 'groups' ? snapshotArg.groups[idArg].action : resourceArg === 'sensors' ? sectionArg === 'config' ? snapshotArg.sensors[idArg].config : snapshotArg.sensors[idArg].state : snapshotArg.lights[idArg].state;
+  if (!state || state.reachable === false || resourceArg === 'sensors' && snapshotArg.sensors[idArg].config?.reachable === false) throw new Error('deCONZ resource is unavailable.');
+  if (resourceArg === 'groups' && !snapshotArg.groups[idArg].lights?.length) throw new Error('deCONZ group has no current members.');
+  for (const [key, value] of Object.entries(patchArg)) {
+    if (resourceArg === 'lights' && ['ct', 'hue', 'sat', 'xy'].includes(key)) {
+      const light = snapshotArg.lights[idArg];
+      const mode = key === 'hue' || key === 'sat' ? 'hs' : key;
+      const modes = light.modes ?? (Array.isArray(light.colorcapabilities) ? light.colorcapabilities : undefined);
+      const mask = mode === 'ct' ? 16 : mode === 'xy' ? 8 : 3;
+      if (modes && !modes.includes(mode) || typeof light.colorcapabilities === 'number' && !(light.colorcapabilities & mask)) throw new Error('deCONZ color control is not currently advertised.');
+    }
+    if (key === 'transitiontime') {
+      if (!Object.keys(patchArg).some((entryArg) => ['bri', 'ct', 'hue', 'sat', 'xy', 'on'].includes(entryArg))) throw new Error('deCONZ transition requires an actual lighting control.');
+      continue;
+    }
+    if (key === 'colorloopspeed') {
+      if (patchArg.effect !== 'colorloop') throw new Error('deCONZ colorloop speed requires a selected effect.');
+      continue;
+    }
+    if (key === 'toggle' && resourceArg === 'groups' && typeof state.on === 'boolean') continue;
+    if (key === 'stop' && resourceArg === 'lights' && typeof state.open === 'boolean') continue;
+    if (key === 'setvalve' && resourceArg === 'sensors' && typeof state.valve === 'number') continue;
+    if (key === 'effect' && resourceArg === 'lights') {
+      const effects = snapshotArg.lights[idArg].effects;
+      if (!Array.isArray(effects) || !effects.includes(String(value)) || typeof state.effect !== 'string') throw new Error('deCONZ effect is not currently advertised.');
+      continue;
+    }
+    if (state[key] === undefined || key !== 'lift' && typeof value !== typeof state[key]) throw new Error('deCONZ control field is not currently supported.');
+    if (key === 'ct' && resourceArg === 'lights') {
+      const light = snapshotArg.lights[idArg];
+      if (!Number.isInteger(light.ctmin) || !Number.isInteger(light.ctmax) || light.ctmin! < 1 || light.ctmax! < light.ctmin! || typeof value !== 'number' || value < light.ctmin! || value > light.ctmax!) throw new Error('deCONZ color temperature is outside current advertised bounds.');
+    }
+    if (key === 'ct' && resourceArg === 'groups' && (typeof value !== 'number' || value < 153 || value > 500)) throw new Error('deCONZ group color temperature is outside supported bounds.');
+  }
+}
 
 type TDeconzPatchValue = string | number | boolean | number[];
 type TDeconzPatchValidator = (valueArg: unknown) => boolean;
@@ -46,6 +186,7 @@ const LIGHT_PATCH_FIELDS = {
 
 const GROUP_PATCH_FIELDS = {
   ...LIGHTING_PATCH_FIELDS,
+  ct: integerRange(153, 500),
   alert: stringValues(['none', 'select', 'lselect']),
   effect: stringValues(['none', 'colorloop']),
   toggle: booleanValue,
@@ -187,7 +328,7 @@ function state(valueArg: unknown): void {
   if (Object.values(valueArg).some((entryArg) => typeof entryArg === 'number' && !Number.isFinite(entryArg))) throw new Error('Invalid deCONZ numeric state.');
   fields(valueArg, ['alert', 'colormode', 'effect', 'airquality', 'lastupdated', 'mode', 'fanmode', 'preset'], 'string');
   fields(valueArg, ['on', 'open', 'reachable', 'all_on', 'any_on', 'alarm', 'carbonmonoxide', 'fire', 'flag', 'presence', 'vibration', 'water', 'tampered', 'lowbattery', 'dark', 'daylight', 'locked', 'stop'], 'boolean');
-  fields(valueArg, ['bri', 'ct', 'hue', 'sat', 'tilt', 'speed', 'consumption', 'current', 'humidity', 'lux', 'lightlevel', 'power', 'pressure', 'status', 'temperature', 'voltage', 'heatsetpoint', 'coolsetpoint', 'offset', 'valve', 'airqualityppb'], 'number');
+  fields(valueArg, ['bri', 'ct', 'hue', 'sat', 'tilt', 'speed', 'consumption', 'current', 'humidity', 'lux', 'lightlevel', 'power', 'pressure', 'status', 'temperature', 'voltage', 'heatsetpoint', 'coolsetpoint', 'offset', 'valve', 'airqualityppb', 'gesture', 'duration'], 'number');
   for (const key of ['battery', 'buttonevent']) {
     if (valueArg[key] !== null) fields(valueArg, [key], 'number');
   }
@@ -204,6 +345,14 @@ function resource(valueArg: unknown, kindArg: 'lights' | 'groups' | 'sensors'):
   record(valueArg.state);
   if (kindArg === 'sensors') record(valueArg.config);
   for (const key of ['state', 'config', 'action']) if (valueArg[key] !== undefined) state(valueArg[key]);
+  if (kindArg === 'lights') {
+    fields(valueArg, ['ctmin', 'ctmax'], 'number');
+    for (const key of ['modes', 'colorcapabilities']) {
+      const value = valueArg[key];
+      if (value !== undefined && !(key === 'colorcapabilities' && typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 65535) && (!Array.isArray(value) || value.some((itemArg) => typeof itemArg !== 'string'))) throw new Error('Invalid deCONZ advertised color capabilities.');
+    }
+    if (valueArg.effects !== undefined && (!Array.isArray(valueArg.effects) || valueArg.effects.some((itemArg) => typeof itemArg !== 'string' || !itemArg))) throw new Error('Invalid deCONZ advertised effects.');
+  }
   if (kindArg === 'groups') {
     for (const key of ['lights', 'devicemembership', 'lightsequence', 'multideviceids']) {
       const value = valueArg[key];
@@ -223,6 +372,20 @@ function resource(valueArg: unknown, kindArg: 'lights' | 'groups' | 'sensors'):
   }
 }
 
+const stateKeys = ['alert', 'bri', 'colormode', 'ct', 'effect', 'hue', 'lift', 'on', 'open', 'reachable', 'sat', 'speed', 'stop', 'tilt', 'xy', 'all_on', 'any_on', 'airquality', 'airqualityppb', 'alarm', 'battery', 'buttonevent', 'carbonmonoxide', 'consumption', 'current', 'dark', 'daylight', 'fire', 'flag', 'gesture', 'humidity', 'lastupdated', 'lightlevel', 'lux', 'power', 'presence', 'pressure', 'status', 'temperature', 'vibration', 'voltage', 'water', 'coolsetpoint', 'fanmode', 'heatsetpoint', 'locked', 'lowbattery', 'mode', 'offset', 'preset', 'tampered', 'valve', 'duration'];
+const resourceKeys = ['id', 'colorcapabilities', 'modes', 'ctmax', 'ctmin', 'effects', 'etag', 'hascolor', 'lastannounced', 'lastseen', 'manufacturername', 'modelid', 'name', 'swversion', 'type', 'uniqueid', 'devicemembership', 'hidden', 'lights', 'lightsequence', 'multideviceids', 'scenes', 'class', 'ep', 'mode'];
+function cleanState(valueArg: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(valueArg).filter(([key]) => stateKeys.includes(key)));
+}
+function cleanResource(valueArg: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const key of resourceKeys) if (valueArg[key] !== undefined) {
+    result[key] = key === 'scenes' ? Object.values(valueArg[key] as Record<string, Record<string, unknown>>).map((scene) => ({ id: scene.id, ...(scene.name !== undefined ? { name: scene.name } : {}) })) : structuredClone(valueArg[key]);
+  }
+  for (const section of ['state', 'config', 'action']) if (isDeconzRecord(valueArg[section])) result[section] = cleanState(valueArg[section]);
+  return result;
+}
+
 export function deconzSnapshot(valueArg: unknown): IDeconzSnapshot {
   record(valueArg);
   const config = deconzGatewayConfig(valueArg.config);
@@ -240,7 +403,13 @@ export function deconzSnapshot(valueArg: unknown): IDeconzSnapshot {
       fields(item, ['id', 'groupId', 'name'], 'string');
     }
   }
-  return { ...valueArg, config } as IDeconzSnapshot;
+  const result: IDeconzSnapshot = { config, lights: {}, groups: {}, sensors: {} };
+  for (const kind of ['lights', 'groups', 'sensors'] as const) {
+    for (const [id, itemArg] of Object.entries(valueArg[kind] as Record<string, Record<string, unknown>>)) {
+      result[kind][id] = cleanResource(itemArg);
+    }
+  }
+  return result;
 }
 
 export function deconzWebsocketEvent(valueArg: unknown): IDeconzWebsocketEvent {
@@ -257,5 +426,9 @@ export function deconzWebsocketEvent(valueArg: unknown): IDeconzWebsocketEvent {
     if (valueArg[key] !== undefined) resource(valueArg[key], kind);
     if (valueArg.e === 'added' && valueArg.r === kind && valueArg[key] === undefined) throw new Error('Invalid deCONZ added event.');
   }
-  return valueArg as unknown as IDeconzWebsocketEvent;
+  const result: Record<string, unknown> = {};
+  for (const key of ['t', 'e', 'r', 'id', 'gid', 'scid', 'uniqueid', 'name']) if (valueArg[key] !== undefined) result[key] = valueArg[key];
+  for (const key of ['state', 'config']) if (isDeconzRecord(valueArg[key])) result[key] = cleanState(valueArg[key]);
+  for (const key of ['light', 'group', 'sensor', 'scene']) if (isDeconzRecord(valueArg[key])) result[key] = cleanResource(valueArg[key]);
+  return result as unknown as IDeconzWebsocketEvent;
 }

package/ts/integrations/deconz/readme.md

@@ -8,6 +8,20 @@ For reporting bugs, issues, or security vulnerabilities, please visit [community
 
 ## Direct write contracts
 
+Setup and config-flow contexts require an independently selected `homeId`. The same home must appear in `IDeconzConfig`; an optional constructor `homeId` is an additional constraint. Integration, flow, runtime and public client operations share immutable home admission. Native device and entity identifiers include the owning home, selected bridge and exact resource identity.
+
+Durable configuration contains `homeId`, `host`, optional `port`/`protocol`, the selected `bridgeId`, and a `credentialReference`. Inline API keys, fixture snapshots and caller-selected WebSocket ports are rejected. Supply an `IDeconzCredentialProvider` through constructor options, or an actual `NoSqlConfigStore` scoped to that home and `deconz`. The provider receives a frozen request containing the captured home, origin, bridge, reference, cancellation signal and monotonic deadline. It is the sole credential source when supplied; failed resolution never falls back to another source. A store envelope contains version 1 and the exact home, origin, bridge, reference and API key, encrypted by the store. Credential creation uses the store's insert-only `create` operation or the provider's `create` contract. Callers migrate existing keys into their credential provider or encrypted store before adopting reference configuration.
+
+An integration may construct its own store from a caller-owned database and external encryption key provider. Only that store is closed; injected stores, databases and key providers remain caller-owned. Owned-store retry uses the public `NoSqlConfigStore.retryCleanup` contract.
+
+Control permissions are supplied only through constructor `controlPermissions` and default to denied. Each permission names an exact resource kind, resource ID and permitted fields; configuration, discovery advertisements, forms, device features and stored credentials do not grant permission. Pairing requires a `config` permission for the selected bridge with both `pair` and `credentials:create`; accepting a supplied pairing key still requires `credentials:create`. Returned flow configuration contains the reference, never the key. An issued form becomes terminal when its owner closes or pairing/storage becomes indeterminate.
+
+Before credentials are dispatched, the client checks the currently reported selected bridge through the public configuration endpoint. Commands then read current resources and check exact targets, supported fields, types, advertised color modes/effects and temperature bounds. This comparison checks a reported identifier; it does not cryptographically authenticate a LAN peer. Light, switch, covering, group, thermostat and writable CLIP controls remain available when their current capabilities and owner permissions allow them.
+
+Each accepted command sends one PUT and performs an independent supported REST snapshot read. Its result contains `effectOutcome: 'accepted'`, `observedState`, `causalityConfirmed: false` and `physicalCompletion: 'unconfirmed'`. An acknowledgement does not prove a physical device changed, and matching readback does not prove the command caused it. Failure after dispatch produces an indeterminate result; shutdown and explicit cleanup retry never replay a command. Generic `post` creation has no supported control contract and is denied.
+
+The shared capacity defaults to 16 and includes live runtimes, subscriptions, pending operations and retained cleanup. A runtime command uses one operation slot through validation and readback. Asynchronous event/error callbacks retain their actual promises. Deadlines abort transport and prevent late credential dispatch; noncooperative callbacks remain owned until they settle. `destroy()` is terminal and memoized, joins sibling cleanup despite failures, and retains failed handles. Only `retryCleanup()` retries cleanup or acknowledges settled callback failures. Borrowed-store internals remain under the injected store owner's lifecycle.
+
 `DeconzClient.setLightState`, `setGroupState` and `setSensorConfig` accept explicit patch interfaces. Patches must be non-empty plain objects containing enumerable data properties. Unknown fields, nested objects, accessors, serialization hooks and values outside the protocol types or ranges are rejected before HTTP I/O. Read response fields such as light `reachable` and `colormode`, group `all_on`, and sensor `temperature`, `lowbattery`, `tampered` and `valve` are not write fields.
 
 | Method | Accepted fields |
@@ -16,7 +30,7 @@ For reporting bugs, issues, or security vulnerabilities, please visit [community
 | `setGroupState` | `alert`, `bri`, `colorloopspeed`, `ct`, `effect`, `hue`, `on`, `sat`, `transitiontime`, `xy`, `toggle` |
 | `setSensorConfig` | `battery`, `coolsetpoint`, `fanmode`, `heatsetpoint`, `locked`, `mode`, `offset`, `on`, `preset`, `reachable`, `setvalve` |
 
-Brightness and saturation use integers from 0 to 255; hue uses 0 to 65535; color coordinates are two finite numbers from 0 to 1. Color temperature is an integer from 1 to 65535 mireds; each device can impose narrower limits. Transition time uses integer tenths of a second from 0 to 65535. `colorloopspeed` uses 1 to 255 and requires `effect: 'colorloop'`. Light effect names remain device dependent and must be non-empty strings; group effects are `'none'` or `'colorloop'`. Light alert names include the gateway's documented identify and trigger effects; group alerts are `'none'`, `'select'` or `'lselect'`.
+Brightness and saturation use integers from 0 to 255; hue uses 0 to 65535; color coordinates are two finite numbers from 0 to 1. Color temperature is an integer from 1 to 65535 mireds for lights, bounded by their current advertised `ctmin`/`ctmax`; group controls use 153 to 500. Transition time uses integer tenths of a second from 0 to 65535. `colorloopspeed` uses 1 to 255 and requires `effect: 'colorloop'`. Light effect names remain device dependent and must be non-empty strings; group effects are `'none'` or `'colorloop'`. Light alert names include the gateway's documented identify and trigger effects; group alerts are `'none'`, `'select'` or `'lselect'`.
 
 Window covering `lift` is an integer percentage closed from 0 to 100 or `'stop'`; `tilt` uses 0 to 100 and fan `speed` uses 0 to 6. Sensor setpoints use hundredths of a degree: `heatsetpoint` is 500 to 3200 and `coolsetpoint` is 700 to 3500. `offset` uses a signed 16-bit integer. Sensor mode, fan mode and preset strings are restricted to the documented choices in `IDeconzSensorConfigPatch`. Availability of each write field still depends on the gateway resource; a protocol-valid patch does not grant a device capability.