homebridge-mg-smarthome 0.1.1

package/README.md

@@ -0,0 +1,159 @@
+# MG Smarthome Homebridge Integration
+
+This directory contains the custom Homebridge Dynamic Platform Plugin for MG Smarthome.
+
+## What It Does
+
+- connects Homebridge to the existing MQTT broker
+- subscribes to `room-monitoring/+/data`
+- parses payloads like `01,20.10,47.50`
+- creates separate HomeKit accessories for temperature and humidity
+- restores cached accessories on restart
+- prunes cached accessories that are not rediscovered from active MQTT devices
+- keeps device freshness state with:
+  - stale after 5 minutes
+  - offline after 30 minutes
+
+## Project Structure
+
+```text
+homebridge_integration/
+  package.json
+  tsconfig.json
+  README.md
+  src/
+    index.ts
+    platform.ts
+    platformAccessory.ts
+    mqttClient.ts
+    payloadParser.ts
+    sensorTypes.ts
+    settings.ts
+    configTypes.ts
+  test/
+    payloadParser.test.ts
+```
+
+## Install
+
+1. Install Node.js 18 or newer.
+2. Change into `homebridge_integration/`.
+3. Run `npm install`.
+4. Build the plugin with `npm run build`.
+5. Link or install the plugin into the Homebridge environment.
+
+Example local link workflow:
+
+```bash
+cd homebridge_integration
+npm install
+npm run build
+npm link
+cd /var/lib/homebridge
+npm link homebridge-mg-smarthome
+```
+
+## Homebridge Configuration
+
+The Flask application can generate the JSON block from:
+
+```text
+/settings/homebridge/administration
+```
+
+The export endpoints are admin-only and read-only:
+
+- `/settings/homebridge/administration`
+- `/settings/homebridge/export.json`
+- `/settings/homebridge/download`
+
+Example platform block:
+
+```json
+{
+  "platform": "MGSmarthome",
+  "name": "MG Smarthome",
+  "mqtt": {
+    "host": "localhost",
+    "port": 1883,
+    "username": "<user>",
+    "password": "<password>",
+    "protocol": "mqtt",
+    "clientId": "homebridge-mg-smarthome"
+  },
+  "topics": {
+    "data": "room-monitoring/+/data"
+  },
+  "qos": 0,
+  "thresholds": {
+    "staleMinutes": 5,
+    "offlineMinutes": 30
+  },
+  "debounceMs": 500,
+  "debug": false,
+  "sensorTypes": {
+    "01": {
+      "name": "Room Monitoring",
+      "values": [
+        {
+          "index": 1,
+          "type": "temperature",
+          "service": "TemperatureSensor",
+          "characteristic": "CurrentTemperature",
+          "unit": "celsius",
+          "min": -50,
+          "max": 100
+        },
+        {
+          "index": 2,
+          "type": "humidity",
+          "service": "HumiditySensor",
+          "characteristic": "CurrentRelativeHumidity",
+          "unit": "percent",
+          "min": 0,
+          "max": 100
+        }
+      ]
+    }
+  }
+}
+```
+
+Add that block inside Homebridge `config.json` under `platforms`.
+
+Note:
+The current export design includes real MQTT credential values and does not mask the password in the generated JSON. This matches the current project decision for copy/download export and is not intended as a hardened secret-management model.
+
+## Run Locally
+
+1. Start Homebridge with the plugin installed.
+2. Verify the log contains:
+   - MQTT connection success
+   - topic subscription success
+   - accessory discovery messages
+3. Publish a test message:
+
+```bash
+mosquitto_pub -h 127.0.0.1 -p 1883 -t room-monitoring/24DCC3C11E2C/data -m "01,20.10,47.50"
+```
+
+## Expected Apple Home Result
+
+- one temperature accessory for the active device
+- one humidity accessory for the active device
+- both accessories update from MQTT payloads
+
+Current design note:
+The plugin currently uses multiple HomeKit accessories per physical device rather than one accessory with multiple services.
+
+## Tests
+
+Run the TypeScript parser tests with:
+
+```bash
+npm test
+```
+
+## Flask Export
+
+The export is read-only and does not modify Homebridge files directly.

package/dist/src/configTypes.d.ts

@@ -0,0 +1,85 @@
+import type { PlatformAccessory } from 'homebridge';
+import type { MqttProtocol } from 'mqtt';
+export type MQTTQoS = 0 | 1 | 2;
+export interface MqttConfig {
+    host: string;
+    port: number;
+    username?: string;
+    password?: string;
+    protocol?: MqttProtocol;
+    clientId?: string;
+}
+export interface TopicConfig {
+    data: string;
+}
+export interface SensorValueConfig {
+    index: number;
+    type: string;
+    service: 'TemperatureSensor' | 'HumiditySensor';
+    characteristic: 'CurrentTemperature' | 'CurrentRelativeHumidity';
+    unit: string;
+    min: number;
+    max: number;
+}
+export interface SensorTypeConfig {
+    name: string;
+    values: SensorValueConfig[];
+}
+export interface DeviceOverrideConfig {
+    name?: string;
+    room?: string;
+    accessories?: Record<string, string>;
+}
+export interface ThresholdConfig {
+    staleMinutes: number;
+    offlineMinutes: number;
+}
+export interface MGSmarthomePlatformConfig {
+    platform: string;
+    name: string;
+    mqtt: MqttConfig;
+    topics: TopicConfig;
+    qos?: MQTTQoS;
+    thresholds?: ThresholdConfig;
+    debounceMs?: number;
+    debug?: boolean;
+    sensorTypes?: Record<string, SensorTypeConfig>;
+    devices?: Record<string, DeviceOverrideConfig>;
+}
+export interface AccessoryContext {
+    cacheKey: string;
+    deviceId: string;
+    sensorType: string;
+    valueType: string;
+    displayName: string;
+    lastValue?: number;
+    lastSeenAt?: number;
+    staleState?: 'fresh' | 'stale' | 'offline';
+    seenThisSession?: boolean;
+    restoredFromCache?: boolean;
+    room?: string;
+    valueDefinition?: SensorValueConfig;
+}
+export type MGAccessory = PlatformAccessory<AccessoryContext>;
+export interface ParsedValueUpdate {
+    value: number;
+    definition: SensorValueConfig;
+}
+export interface ParsedValueIssue {
+    definition: SensorValueConfig;
+    rawValue?: string;
+    reason: string;
+}
+export interface ParsedPayloadSuccess {
+    ok: true;
+    sensorType: string;
+    validUpdates: ParsedValueUpdate[];
+    invalidUpdates: ParsedValueIssue[];
+}
+export interface ParsedPayloadFailure {
+    ok: false;
+    sensorType?: string;
+    reason: string;
+    invalidUpdates: ParsedValueIssue[];
+}
+export type ParsedPayloadResult = ParsedPayloadSuccess | ParsedPayloadFailure;

package/dist/src/configTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+import { API } from 'homebridge';
+declare const _default: (api: API) => void;
+export = _default;

package/dist/src/index.js

@@ -0,0 +1,6 @@
+"use strict";
+const platform_1 = require("./platform");
+const settings_1 = require("./settings");
+module.exports = (api) => {
+    api.registerPlatform(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, platform_1.MGSmarthomePlatform);
+};

package/dist/src/mqttClient.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from 'homebridge';
+import { MGSmarthomePlatformConfig } from './configTypes';
+interface MqttCallbacks {
+    onMessage: (topic: string, payload: Buffer) => void;
+}
+export declare class MGSmarthomeMqttClient {
+    private readonly log;
+    private readonly config;
+    private client?;
+    constructor(log: Logger, config: Required<MGSmarthomePlatformConfig>);
+    start(callbacks: MqttCallbacks): void;
+    stop(): void;
+}
+export {};

package/dist/src/mqttClient.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MGSmarthomeMqttClient = void 0;
+const mqtt_1 = __importDefault(require("mqtt"));
+class MGSmarthomeMqttClient {
+    log;
+    config;
+    client;
+    constructor(log, config) {
+        this.log = log;
+        this.config = config;
+    }
+    start(callbacks) {
+        const options = {
+            host: this.config.mqtt.host,
+            port: this.config.mqtt.port,
+            protocol: this.config.mqtt.protocol,
+            username: this.config.mqtt.username || undefined,
+            password: this.config.mqtt.password || undefined,
+            clientId: this.config.mqtt.clientId,
+            reconnectPeriod: 2000,
+            keepalive: 60,
+            clean: true,
+        };
+        this.client = mqtt_1.default.connect(options);
+        this.client.on('connect', () => {
+            this.log.info(`Connected to MQTT broker ${this.config.mqtt.host}:${this.config.mqtt.port}`);
+            this.client?.subscribe(this.config.topics.data, { qos: this.config.qos }, (error) => {
+                if (error) {
+                    this.log.error(`Failed to subscribe to ${this.config.topics.data}: ${error.message}`);
+                    return;
+                }
+                this.log.info(`Subscribed to ${this.config.topics.data} with QoS ${this.config.qos}`);
+            });
+        });
+        this.client.on('reconnect', () => {
+            this.log.warn('MQTT reconnect in progress');
+        });
+        this.client.on('error', (error) => {
+            this.log.error(`MQTT error: ${error.message}`);
+        });
+        this.client.on('message', (topic, payload) => {
+            callbacks.onMessage(topic, payload);
+        });
+    }
+    stop() {
+        this.client?.end(true);
+        this.client = undefined;
+    }
+}
+exports.MGSmarthomeMqttClient = MGSmarthomeMqttClient;

package/dist/src/payloadParser.d.ts

@@ -0,0 +1,3 @@
+import { ParsedPayloadResult, SensorTypeConfig } from './configTypes';
+export declare function extractDeviceIdFromTopic(topic: string, pattern: string): string | null;
+export declare function parsePayload(payload: Buffer | string, sensorTypes: Record<string, SensorTypeConfig>): ParsedPayloadResult;

package/dist/src/payloadParser.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDeviceIdFromTopic = extractDeviceIdFromTopic;
+exports.parsePayload = parsePayload;
+function extractDeviceIdFromTopic(topic, pattern) {
+    const escapedPattern = pattern.replace(/[.*?^${}()|[\]\\]/g, '\\$&');
+    const topicRegex = new RegExp(`^${escapedPattern.replace(/\\\+/g, '([^/]+)')}$`);
+    const match = topic.match(topicRegex);
+    if (!match || !match[1]) {
+        return null;
+    }
+    return match[1];
+}
+function parsePayload(payload, sensorTypes) {
+    const rawPayload = typeof payload === 'string' ? payload : payload.toString('utf8');
+    const payloadParts = rawPayload.split(',').map((value) => value.trim());
+    const sensorType = payloadParts[0];
+    if (!sensorType) {
+        return {
+            ok: false,
+            reason: 'Payload does not contain a sensor type.',
+            invalidUpdates: [],
+        };
+    }
+    const sensorTypeConfig = sensorTypes[sensorType];
+    if (!sensorTypeConfig) {
+        return {
+            ok: false,
+            sensorType,
+            reason: `Unsupported sensor type "${sensorType}".`,
+            invalidUpdates: [],
+        };
+    }
+    const validUpdates = [];
+    const invalidUpdates = [];
+    for (const valueDefinition of sensorTypeConfig.values) {
+        const rawValue = payloadParts[valueDefinition.index];
+        if (rawValue === undefined || rawValue === '') {
+            invalidUpdates.push({
+                definition: valueDefinition,
+                rawValue,
+                reason: 'Missing value.',
+            });
+            continue;
+        }
+        const parsedValue = Number(rawValue.replace(',', '.'));
+        if (!Number.isFinite(parsedValue)) {
+            invalidUpdates.push({
+                definition: valueDefinition,
+                rawValue,
+                reason: 'Value is not numeric.',
+            });
+            continue;
+        }
+        if (parsedValue < valueDefinition.min || parsedValue > valueDefinition.max) {
+            invalidUpdates.push({
+                definition: valueDefinition,
+                rawValue,
+                reason: `Value is outside the allowed range ${valueDefinition.min}..${valueDefinition.max}.`,
+            });
+            continue;
+        }
+        validUpdates.push({
+            definition: valueDefinition,
+            value: parsedValue,
+        });
+    }
+    if (validUpdates.length === 0) {
+        return {
+            ok: false,
+            sensorType,
+            reason: 'Payload does not contain any valid mapped values.',
+            invalidUpdates,
+        };
+    }
+    return {
+        ok: true,
+        sensorType,
+        validUpdates,
+        invalidUpdates,
+    };
+}

package/dist/src/platform.d.ts

@@ -0,0 +1,24 @@
+import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, PlatformConfig } from 'homebridge';
+import { AccessoryContext } from './configTypes';
+export declare class MGSmarthomePlatform implements DynamicPlatformPlugin {
+    readonly log: Logger;
+    readonly api: API;
+    private readonly config;
+    private readonly mqttClient;
+    private readonly accessories;
+    private readonly pendingUpdates;
+    private readonly pendingTimers;
+    private readonly unsupportedSensorTypes;
+    private startupPruneTimer?;
+    private stalenessTimer?;
+    constructor(log: Logger, rawConfig: PlatformConfig, api: API);
+    configureAccessory(accessory: PlatformAccessory<AccessoryContext>): void;
+    private handleMqttMessage;
+    private ensureAccessory;
+    private queueUpdate;
+    private applyUpdate;
+    private buildAccessoryName;
+    private scheduleStartupPrune;
+    private scheduleStalenessChecks;
+    private clearTimers;
+}

package/dist/src/platform.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MGSmarthomePlatform = void 0;
+const mqttClient_1 = require("./mqttClient");
+const payloadParser_1 = require("./payloadParser");
+const platformAccessory_1 = require("./platformAccessory");
+const sensorTypes_1 = require("./sensorTypes");
+const settings_1 = require("./settings");
+class MGSmarthomePlatform {
+    log;
+    api;
+    config;
+    mqttClient;
+    accessories = new Map();
+    pendingUpdates = new Map();
+    pendingTimers = new Map();
+    unsupportedSensorTypes = new Set();
+    startupPruneTimer;
+    stalenessTimer;
+    constructor(log, rawConfig, api) {
+        this.log = log;
+        this.api = api;
+        this.config = (0, settings_1.normalizeConfig)(rawConfig);
+        this.mqttClient = new mqttClient_1.MGSmarthomeMqttClient(this.log, this.config);
+        this.api.on('didFinishLaunching', () => {
+            this.log.info('Homebridge finished launching MG Smarthome platform');
+            this.scheduleStartupPrune();
+            this.scheduleStalenessChecks();
+            this.mqttClient.start({
+                onMessage: (topic, payload) => this.handleMqttMessage(topic, payload),
+            });
+        });
+        this.api.on('shutdown', () => {
+            this.clearTimers();
+            this.mqttClient.stop();
+        });
+    }
+    configureAccessory(accessory) {
+        accessory.context.restoredFromCache = true;
+        accessory.context.seenThisSession = false;
+        const valueDefinition = accessory.context.valueDefinition;
+        const sensorTypeConfig = this.config.sensorTypes[accessory.context.sensorType] ?? sensorTypes_1.DEFAULT_SENSOR_TYPES[accessory.context.sensorType];
+        if (!valueDefinition || !sensorTypeConfig) {
+            this.log.warn(`Discarding cached accessory ${accessory.displayName} because its cached mapping is incomplete`);
+            this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            return;
+        }
+        const wrapper = new platformAccessory_1.MGSmarthomePlatformAccessory(this.api, accessory, sensorTypeConfig, valueDefinition);
+        this.accessories.set(accessory.UUID, wrapper);
+    }
+    handleMqttMessage(topic, payload) {
+        const deviceId = (0, payloadParser_1.extractDeviceIdFromTopic)(topic, this.config.topics.data);
+        if (!deviceId) {
+            if (this.config.debug) {
+                this.log.warn(`Ignoring MQTT topic that does not match the data pattern: ${topic}`);
+            }
+            return;
+        }
+        const parsedPayload = (0, payloadParser_1.parsePayload)(payload, this.config.sensorTypes);
+        if (!parsedPayload.ok) {
+            if (parsedPayload.sensorType) {
+                const dedupeKey = `${deviceId}:${parsedPayload.sensorType}`;
+                if (parsedPayload.reason.startsWith('Unsupported sensor type')) {
+                    if (!this.unsupportedSensorTypes.has(dedupeKey)) {
+                        this.unsupportedSensorTypes.add(dedupeKey);
+                        this.log.warn(`${parsedPayload.reason} Topic: ${topic}`);
+                    }
+                    return;
+                }
+            }
+            this.log.warn(`Invalid payload on ${topic}: ${parsedPayload.reason}`);
+            return;
+        }
+        if (this.config.debug) {
+            this.log.debug(`Parsed MQTT payload from ${topic}: ${payload.toString('utf8')}`);
+        }
+        for (const invalidUpdate of parsedPayload.invalidUpdates) {
+            this.log.warn(`Ignoring invalid ${invalidUpdate.definition.type} value for ${deviceId}: ${invalidUpdate.reason}` +
+                `${invalidUpdate.rawValue !== undefined ? ` Raw value: ${invalidUpdate.rawValue}` : ''}`);
+        }
+        const sensorTypeConfig = this.config.sensorTypes[parsedPayload.sensorType];
+        for (const validUpdate of parsedPayload.validUpdates) {
+            const accessoryWrapper = this.ensureAccessory(deviceId, parsedPayload.sensorType, sensorTypeConfig, validUpdate.definition);
+            this.queueUpdate(accessoryWrapper, validUpdate);
+        }
+    }
+    ensureAccessory(deviceId, sensorType, sensorTypeConfig, valueDefinition) {
+        const cacheKey = `${deviceId}:${sensorType}:${valueDefinition.type}`;
+        const uuid = this.api.hap.uuid.generate(cacheKey);
+        const displayName = this.buildAccessoryName(deviceId, sensorType, valueDefinition);
+        const room = this.config.devices[deviceId]?.room;
+        const existingAccessory = this.accessories.get(uuid);
+        if (existingAccessory) {
+            existingAccessory.updateMetadata(displayName, room);
+            existingAccessory.accessory.context.cacheKey = cacheKey;
+            existingAccessory.accessory.context.valueDefinition = valueDefinition;
+            this.api.updatePlatformAccessories([existingAccessory.accessory]);
+            return existingAccessory;
+        }
+        const accessory = new this.api.platformAccessory(displayName, uuid);
+        accessory.context = {
+            cacheKey,
+            deviceId,
+            sensorType,
+            valueType: valueDefinition.type,
+            displayName,
+            room,
+            seenThisSession: true,
+            restoredFromCache: false,
+            staleState: 'fresh',
+            valueDefinition,
+        };
+        const wrapper = new platformAccessory_1.MGSmarthomePlatformAccessory(this.api, accessory, sensorTypeConfig, valueDefinition);
+        this.accessories.set(uuid, wrapper);
+        this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+        this.log.info(`Discovered accessory ${displayName} from device ${deviceId}`);
+        return wrapper;
+    }
+    queueUpdate(wrapper, update) {
+        const uuid = wrapper.accessory.UUID;
+        const now = Date.now();
+        wrapper.markSeen(now);
+        wrapper.setStaleState('fresh');
+        this.api.updatePlatformAccessories([wrapper.accessory]);
+        if (this.config.debounceMs <= 0) {
+            this.applyUpdate(wrapper, update.value, now);
+            return;
+        }
+        this.pendingUpdates.set(uuid, {
+            wrapper,
+            value: update.value,
+            timestamp: now,
+        });
+        const existingTimer = this.pendingTimers.get(uuid);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(() => {
+            const pendingUpdate = this.pendingUpdates.get(uuid);
+            if (!pendingUpdate) {
+                return;
+            }
+            this.applyUpdate(pendingUpdate.wrapper, pendingUpdate.value, pendingUpdate.timestamp);
+            this.pendingUpdates.delete(uuid);
+            this.pendingTimers.delete(uuid);
+        }, this.config.debounceMs);
+        this.pendingTimers.set(uuid, timer);
+    }
+    applyUpdate(wrapper, value, timestamp) {
+        wrapper.markSeen(timestamp);
+        const didUpdate = wrapper.updateValue(value);
+        this.api.updatePlatformAccessories([wrapper.accessory]);
+        if (didUpdate && this.config.debug) {
+            this.log.debug(`Updated ${wrapper.accessory.displayName} to ${value}`);
+        }
+    }
+    buildAccessoryName(deviceId, sensorType, valueDefinition) {
+        const deviceOverride = this.config.devices[deviceId];
+        const accessoryOverrideKey = `${sensorType}:${valueDefinition.type}`;
+        const accessoryOverrideName = deviceOverride?.accessories?.[accessoryOverrideKey];
+        if (accessoryOverrideName) {
+            return accessoryOverrideName;
+        }
+        const baseName = deviceOverride?.name || deviceId;
+        const suffix = valueDefinition.type.replace('_', ' ').replace(/\b\w/g, (character) => character.toUpperCase());
+        return `${baseName} ${suffix}`;
+    }
+    scheduleStartupPrune() {
+        const pruneDelayMinutes = Math.max(1, this.config.thresholds.staleMinutes || settings_1.DEFAULT_STALE_MINUTES);
+        this.startupPruneTimer = setTimeout(() => {
+            const accessoriesToRemove = [];
+            for (const wrapper of this.accessories.values()) {
+                if (wrapper.accessory.context.restoredFromCache && !wrapper.accessory.context.seenThisSession) {
+                    accessoriesToRemove.push(wrapper.accessory);
+                    this.accessories.delete(wrapper.accessory.UUID);
+                }
+            }
+            if (accessoriesToRemove.length > 0) {
+                this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, accessoriesToRemove);
+                this.log.info(`Removed ${accessoriesToRemove.length} cached accessories that were not rediscovered from active MQTT devices`);
+            }
+        }, pruneDelayMinutes * 60 * 1000);
+    }
+    scheduleStalenessChecks() {
+        this.stalenessTimer = setInterval(() => {
+            const now = Date.now();
+            const staleThresholdMs = this.config.thresholds.staleMinutes * 60 * 1000;
+            const offlineThresholdMs = this.config.thresholds.offlineMinutes * 60 * 1000;
+            for (const wrapper of this.accessories.values()) {
+                const lastSeenAt = wrapper.accessory.context.lastSeenAt;
+                if (!lastSeenAt) {
+                    continue;
+                }
+                let staleState = 'fresh';
+                const ageMs = now - lastSeenAt;
+                if (ageMs >= offlineThresholdMs) {
+                    staleState = 'offline';
+                }
+                else if (ageMs >= staleThresholdMs) {
+                    staleState = 'stale';
+                }
+                const didChange = wrapper.setStaleState(staleState);
+                if (didChange) {
+                    this.api.updatePlatformAccessories([wrapper.accessory]);
+                    if (this.config.debug) {
+                        this.log.debug(`${wrapper.accessory.displayName} is now ${staleState}`);
+                    }
+                }
+            }
+        }, 60 * 1000);
+    }
+    clearTimers() {
+        if (this.startupPruneTimer) {
+            clearTimeout(this.startupPruneTimer);
+        }
+        if (this.stalenessTimer) {
+            clearInterval(this.stalenessTimer);
+        }
+        for (const timer of this.pendingTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.pendingTimers.clear();
+        this.pendingUpdates.clear();
+    }
+}
+exports.MGSmarthomePlatform = MGSmarthomePlatform;

package/dist/src/platformAccessory.d.ts

@@ -0,0 +1,17 @@
+import { API, PlatformAccessory } from 'homebridge';
+import { AccessoryContext, MGAccessory, SensorTypeConfig, SensorValueConfig } from './configTypes';
+export declare class MGSmarthomePlatformAccessory {
+    private readonly api;
+    private readonly sensorTypeConfig;
+    private readonly valueDefinition;
+    readonly accessory: MGAccessory;
+    private readonly service;
+    constructor(api: API, accessory: PlatformAccessory<AccessoryContext>, sensorTypeConfig: SensorTypeConfig, valueDefinition: SensorValueConfig);
+    updateMetadata(displayName: string, room?: string): void;
+    markSeen(timestamp: number): void;
+    updateValue(value: number): boolean;
+    setStaleState(staleState: 'fresh' | 'stale' | 'offline'): boolean;
+    private getOrCreateSensorService;
+    private getCharacteristicType;
+    private ensureAccessoryInformation;
+}