@camstack/addon-provider-homematic 1.2.161 → 1.2.163

package/dist/index.js

@@ -1,561 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_addon = require("./addon.js");
-//#region src/homematic-device.ts
-/**
-* Persisted config every Homematic-backed device carries. `address` is
-* the CCU device address (e.g. `0001D3C99AB123`) — the dispatch key the
-* device uses to resolve its live `HmDevice` from the facade and to
-* filter inbound `valueChanged` events to its own datapoints.
-*/
-var homematicDeviceSchema = require_addon.object({
-	address: require_addon.string().min(1).describe("CCU device address"),
-	/** The registry broker id this device belongs to (e.g. `hm_001`).
-	*  Absent on devices persisted before the multi-CCU migration; those
-	*  fall back to the primary broker via `homematicFacades.get(null)`. */
-	brokerId: require_addon.string().optional()
-});
-/** Cold-start defaults so reads never miss a slice before the first push. */
-var COLD_SWITCH = {
-	on: false,
-	lastChangedAt: 0
-};
-var COLD_COVER = {
-	state: "closed",
-	position: null,
-	tiltPosition: null,
-	lastChangedAt: 0
-};
-var COLD_LOCK = {
-	state: "unlocked",
-	lastChangedAt: 0
-};
-var COLD_MOTION = {
-	detected: false,
-	lastDetectedAt: null,
-	autoClearAfterMs: null
-};
-var COLD_CLIMATE = {
-	mode: "auto",
-	availableModes: [...[
-		"off",
-		"heat",
-		"auto"
-	]],
-	fanMode: "",
-	availableFanModes: [],
-	preset: "",
-	availablePresets: ["boost"],
-	target: null,
-	targetHigh: null,
-	targetLow: null,
-	targetHumidity: null,
-	currentTemp: null,
-	currentHumidity: null,
-	swingVertical: null,
-	swingHorizontal: null,
-	lastFetchedAt: 0
-};
-/**
-* The standard HmIP key-channel datapoint vocabulary, used VERBATIM (NO
-* normalization) as the `event-emitter` event types. These are the native
-* uppercase tokens a `KEY_TRANSCEIVER` / `KEY_TRANSMITTER` / `VIRTUAL_KEY`
-* / `KEY` channel emits on the facade `valueChanged` stream (via HA they
-* surface lowercased as `press_short` etc.; natively they are uppercase):
-*   - PRESS_SHORT         single short press
-*   - PRESS_LONG          long press (repeats while held on some firmware)
-*   - PRESS_LONG_START    long-press begin
-*   - PRESS_LONG_RELEASE  long-press end
-*   - PRESS_CONT          continuous-press tick while held
-* Used both as the seed vocabulary fallback and as the fire-detection set
-* (a non-key datapoint such as a maintenance LOW_BAT is ignored).
-*/
-var HM_KEY_PRESS_DATAPOINTS = [
-	"PRESS_SHORT",
-	"PRESS_LONG",
-	"PRESS_LONG_START",
-	"PRESS_LONG_RELEASE",
-	"PRESS_CONT"
-];
-/** Set form for O(1) fire-detection membership tests. */
-var HM_KEY_PRESS_SET = new Set(HM_KEY_PRESS_DATAPOINTS);
-/** Cold-start event-emitter slice; vocabulary supplied per-device. */
-function coldEventEmitter(eventTypes) {
-	return {
-		eventTypes: [...eventTypes],
-		lastEvent: null,
-		eventCountSinceStart: 0
-	};
-}
-/**
-* Collect the union of native `PRESS_*` datapoints a device's key channels
-* support, VERBATIM. Reads each key channel's `dataPoints` (when the
-* facade enumerated them) and keeps only the recognised press tokens. Falls
-* back to the standard HmIP key vocabulary when no datapoints were
-* enumerated, so the cap always advertises a non-empty vocabulary.
-*/
-function keyEventVocabulary(keyChannels) {
-	const found = /* @__PURE__ */ new Set();
-	for (const channel of keyChannels) for (const dp of channel.dataPoints ?? []) if (HM_KEY_PRESS_SET.has(dp.parameter)) found.add(dp.parameter);
-	if (found.size === 0) return HM_KEY_PRESS_DATAPOINTS;
-	return HM_KEY_PRESS_DATAPOINTS.filter((dp) => found.has(dp));
-}
-/**
-* The CamStack cap names that are ACTUATORS — driven by the library's typed
-* custom entities (correct channel), NOT by the raw mapped channels. The
-* raw-channel registration loop skips these so they are not double-registered
-* against the wrong channel.
-*/
-var ACTUATOR_CAP_NAMES = new Set([
-	"switch",
-	"cover",
-	"light",
-	"lock-control",
-	"climate-control"
-]);
-/**
-* Map a `nodehomematic` custom-entity `kind` to its CamStack actuator cap
-* name. The union is discriminated by `kind`; the exhaustive switch needs no
-* cast. Returns `null` for kinds with no actuator cap wired yet.
-*/
-function actuatorCapForEntityKind(kind) {
-	switch (kind) {
-		case "switch": return "switch";
-		case "cover":
-		case "blind": return "cover";
-		case "light": return "light";
-		case "lock": return "lock-control";
-		case "climate": return "climate-control";
-		default: return null;
-	}
-}
-/** Parse the numeric channel index suffix (`:N`) from a channel address.
-*  Returns the raw suffix string (kept as a string for the event payload,
-*  mirroring the CCU's `device:index` addressing). Null when absent. */
-function channelIndexFromAddress(channelAddress) {
-	const idx = channelAddress.lastIndexOf(":");
-	if (idx === -1) return null;
-	const suffix = channelAddress.slice(idx + 1);
-	return suffix.length > 0 ? suffix : null;
-}
-/**
-* One CamStack device per Homematic device. Maps the device's channels to
-* CamStack caps (via `homematic-mapping.ts`) and wires each cap's
-* get/set surface to the `nodehomematic` facade's typed helpers
-* (`switchTurnOn` / `coverSetPosition` / `climateSetTemperature` /
-* `lockLock`) and raw `getValue`/`setValue` for read-only sensors.
-*
-* Status flows back via the facade `valueChanged` stream: each push is
-* decoded by parameter name into the relevant cap's runtime-state slice
-* (see `homematic-decode.ts` for the pure decoders).
-*
-* MAPPED (control + status):
-*   - switch          (HmIP-BSM / BS2)
-*   - cover           (HmIP-BROLL)
-*   - climate-control (HmIP-eTRV-C / BWTH / STHD / WTH-2 / HEATING)
-*   - lock-control    (HmIP-DLD)
-* MAPPED (read-only sensors):
-*   - temperature-sensor / humidity-sensor (climate channels)
-*   - motion + ambient-light-sensor        (HmIP-SMI)
-*   - power-meter                          (HmIP-BSM / ESI energy)
-* MAPPED (push-only events):
-*   - event-emitter   (HmIP-WRC* wall switches / HmIP-RC* remotes / key
-*                      channels) — one singleton cap over all key channels;
-*                      native PRESS_* datapoints fired verbatim with the
-*                      button index in `data.channel`.
-*/
-var HomematicDevice = class extends require_addon.BaseDevice {
-	features = [];
-	/** CCU device address — dispatch + event-filter key. */
-	address;
-	/**
-	* Registry broker id this device belongs to. Undefined for devices
-	* persisted before the multi-CCU migration; those resolve to the primary
-	* broker via `homematicFacades.get(null)`.
-	*/
-	brokerId;
-	/** Unsubscribe for the facade `valueChanged` listener. */
-	valueChangedUnsub = null;
-	/** Channel address that owns each registered cap (for decode routing). */
-	capChannels = /* @__PURE__ */ new Map();
-	/** Native press-datapoint vocabulary for this device's key channels
-	*  (verbatim, NO normalization). Empty when the device has no key
-	*  channel — gates the `event-emitter` fire path. */
-	eventTypes = [];
-	/** Monotonic event sequence — two identical presses still produce
-	*  distinct slice writes / bus emissions. */
-	#eventSeq = 0;
-	/** Count of key presses observed since this device instance started. */
-	#eventCount = 0;
-	constructor(ctx) {
-		const persisted = ctx.persistedConfig ?? {};
-		const address = persisted.address;
-		if (typeof address !== "string" || address.length === 0) throw new Error(`HomematicDevice: missing address in persisted config (id=${ctx.id})`);
-		super(ctx, homematicDeviceSchema, { type: ctx.deviceMeta.type });
-		this.address = address;
-		this.brokerId = typeof persisted.brokerId === "string" ? persisted.brokerId : void 0;
-		this.registerAdminLinkCap();
-		this.registerCapabilities();
-		this.attachValueChangedListener();
-		this.updateSourceInfo({
-			id: this.address,
-			system: "homematic"
-		});
-	}
-	/** The live facade for this device's CCU, or null when disconnected. */
-	get facade() {
-		return require_addon.homematicFacades.get(this.brokerId ?? null);
-	}
-	/** Resolve this device's current `HmDevice` snapshot from the facade. */
-	resolveHmDevice() {
-		const facade = this.facade;
-		if (!facade) return null;
-		return facade.devices().find((d) => d.address === this.address) ?? null;
-	}
-	/**
-	* device-admin-link — a Homematic device has no web server; the CCU3 /
-	* RaspberryMatic WebUI is where it is configured. The CCU has no stable
-	* per-device deep link (the WebUI addresses devices through a session-bound
-	* frameset), so every device on a CCU gets that CCU's root, labelled for
-	* what it is. A device persisted before multi-CCU support carries no
-	* `brokerId` and cannot be attributed to a CCU at all — it answers null.
-	*
-	* Registered OUTSIDE `registerCapabilities`, which returns early when the
-	* facade has not yet seen the device: whether the CCU has a WebUI does not
-	* depend on that, and an early return there used to be how a device ended up
-	* with no caps at all.
-	*/
-	registerAdminLinkCap() {
-		const brokerId = this.brokerId;
-		this.ctx.registerNativeCap(require_addon.deviceAdminLinkCapability, { getAdminLink: async ({ deviceId }) => {
-			if (deviceId !== this.id) throw new Error(`HomematicDevice: deviceId mismatch, expected ${this.id}, got ${deviceId}`);
-			if (brokerId === void 0) {
-				this.ctx.logger.debug("homematic admin link unavailable: no brokerId on device", {
-					tags: { deviceId: this.id },
-					meta: { address: this.address }
-				});
-				return null;
-			}
-			const cfg = await this.ctx.api.broker.getBrokerConfig.query({ id: brokerId });
-			const host = typeof cfg?.["host"] === "string" ? cfg["host"] : "";
-			const built = require_addon.buildDeviceAdminUrl({
-				host,
-				port: null,
-				scheme: cfg?.["tls"] === true ? "https" : "http",
-				path: "/"
-			});
-			if (!built.ok) {
-				this.ctx.logger.debug("homematic admin link unavailable", {
-					tags: { deviceId: this.id },
-					meta: {
-						reason: built.reason,
-						brokerId
-					}
-				});
-				return null;
-			}
-			return {
-				url: built.url,
-				label: "CCU WebUI",
-				target: "integration",
-				host
-			};
-		} });
-	}
-	registerCapabilities() {
-		const hmDevice = this.resolveHmDevice();
-		if (!hmDevice) {
-			this.ctx.logger.warn("HomematicDevice: device not found on facade at construction", { meta: { address: this.address } });
-			return;
-		}
-		this.registerActuatorCapsFromCustomEntities();
-		const keyChannels = [];
-		for (const { channel, mapping } of require_addon.mapHmDeviceChannels(hmDevice)) for (const capName of mapping.capabilities) {
-			if (capName === "event-emitter") {
-				keyChannels.push(channel);
-				continue;
-			}
-			if (ACTUATOR_CAP_NAMES.has(capName)) continue;
-			this.registerCap(capName, channel.address);
-		}
-		if (keyChannels.length > 0) this.registerEventEmitterCap(keyChannels);
-	}
-	/**
-	* Register the device's ACTUATOR caps (switch / cover / light / lock /
-	* climate-control) from the library's typed custom entities. Each
-	* `HmCustomEntity` carries the EXACT channel the lib bound the entity to —
-	* the channel the facade control helpers require. The cap channel stored in
-	* `capChannels` is therefore the custom-entity channel, so `coverOpen`
-	* (etc.) dispatch to the correct one.
-	*
-	* When `customEntities()` is empty (facade not fully built yet at
-	* construction time), this is a no-op beyond a debug note; the actuator
-	* caps register on the next reconcile/re-probe once the entities exist.
-	*/
-	registerActuatorCapsFromCustomEntities() {
-		const entities = this.facade?.customEntities()?.filter((e) => e.device === this.address) ?? [];
-		if (entities.length === 0) {
-			this.ctx.logger.debug("HomematicDevice: no custom entities at registration; actuator caps deferred to next reconcile", { meta: { address: this.address } });
-			return;
-		}
-		for (const entity of entities) {
-			const capName = actuatorCapForEntityKind(entity.kind);
-			if (capName === null) continue;
-			this.registerCap(capName, entity.channel);
-		}
-	}
-	/** Dispatch one cap registration to its concrete wiring. */
-	registerCap(capName, channelAddress) {
-		this.capChannels.set(capName, channelAddress);
-		switch (capName) {
-			case "switch": return this.registerSwitchCap(channelAddress);
-			case "cover": return this.registerCoverCap(channelAddress);
-			case "climate-control": return this.registerClimateCap(channelAddress);
-			case "lock-control": return this.registerLockCap(channelAddress);
-			case "motion": return this.registerMotionCap();
-			case "ambient-light-sensor": return require_addon.registerAmbientLightCap(this.ctx, this.runtimeState);
-			case "temperature-sensor": return require_addon.registerTemperatureCap(this.ctx, this.runtimeState);
-			case "humidity-sensor": return require_addon.registerHumidityCap(this.ctx, this.runtimeState);
-			case "power-meter": return require_addon.registerPowerMeterCap(this.ctx, this.runtimeState);
-			default:
-				this.ctx.logger.debug("HomematicDevice: cap not yet wired", { meta: {
-					capName,
-					channelAddress,
-					address: this.address
-				} });
-				return;
-		}
-	}
-	registerSwitchCap(channelAddress) {
-		this.ctx.registerNativeCap(require_addon.switchCapability, {
-			getStatus: async () => this.runtimeState.getCapState("switch") ?? COLD_SWITCH,
-			setState: async ({ on }) => {
-				const facade = this.requireFacade();
-				if (on) await facade.switchTurnOn(this.address, channelAddress);
-				else await facade.switchTurnOff(this.address, channelAddress);
-			}
-		});
-		this.runtimeState.setCapState("switch", COLD_SWITCH);
-	}
-	registerCoverCap(channelAddress) {
-		this.ctx.registerNativeCap(require_addon.coverCapability, {
-			getStatus: async () => this.runtimeState.getCapState("cover") ?? COLD_COVER,
-			open: async () => {
-				await this.requireFacade().coverOpen(this.address, channelAddress);
-			},
-			close: async () => {
-				await this.requireFacade().coverClose(this.address, channelAddress);
-			},
-			stop: async () => {
-				await this.requireFacade().coverStop(this.address, channelAddress);
-			},
-			setPosition: async ({ position }) => {
-				await this.requireFacade().coverSetPosition(this.address, channelAddress, position);
-			},
-			setTiltPosition: async () => this.unsupported("cover tilt")
-		});
-		this.runtimeState.setCapState("cover", COLD_COVER);
-	}
-	registerClimateCap(channelAddress) {
-		this.ctx.registerNativeCap(require_addon.climateControlCapability, {
-			getStatus: async () => this.runtimeState.getCapState("climate-control") ?? COLD_CLIMATE,
-			setMode: async ({ mode }) => {
-				await this.requireFacade().climateSetMode(this.address, channelAddress, require_addon.toHmClimateMode(mode));
-			},
-			setTarget: async ({ target }) => {
-				await this.requireFacade().climateSetTemperature(this.address, channelAddress, target);
-			},
-			setPreset: async ({ preset }) => {
-				await this.requireFacade().climateSetBoost(this.address, channelAddress, preset === "boost");
-			},
-			setFanMode: async () => this.unsupported("climate fan mode"),
-			setTargetRange: async () => this.unsupported("climate dual setpoint"),
-			setTargetHumidity: async () => this.unsupported("climate humidity control"),
-			setSwingVertical: async () => this.unsupported("climate vertical swing"),
-			setSwingHorizontal: async () => this.unsupported("climate horizontal swing")
-		});
-		this.runtimeState.setCapState("climate-control", COLD_CLIMATE);
-	}
-	registerLockCap(channelAddress) {
-		this.ctx.registerNativeCap(require_addon.lockControlCapability, {
-			getStatus: async () => this.runtimeState.getCapState("lock-control") ?? COLD_LOCK,
-			lock: async () => {
-				await this.requireFacade().lockLock(this.address, channelAddress);
-			},
-			unlock: async () => {
-				await this.requireFacade().lockUnlock(this.address, channelAddress);
-			},
-			open: async () => {
-				await this.requireFacade().lockOpen(this.address, channelAddress);
-			}
-		});
-		this.runtimeState.setCapState("lock-control", COLD_LOCK);
-	}
-	registerMotionCap() {
-		this.ctx.registerNativeCap(require_addon.motionCapability, {
-			getStatus: async () => this.runtimeState.getCapState("motion") ?? COLD_MOTION,
-			isDetected: async () => (this.runtimeState.getCapState("motion") ?? COLD_MOTION).detected
-		});
-		this.runtimeState.setCapState("motion", require_addon.coldMotionKeepingRise(this.runtimeState.getCapState("motion")));
-	}
-	registerEventEmitterCap(keyChannels) {
-		this.eventTypes = keyEventVocabulary(keyChannels);
-		this.ctx.registerNativeCap(require_addon.eventEmitterCapability, { getStatus: async () => this.runtimeState.getCapState("event-emitter") ?? coldEventEmitter(this.eventTypes) });
-		this.runtimeState.setCapState("event-emitter", coldEventEmitter(this.eventTypes));
-	}
-	attachValueChangedListener() {
-		const facade = this.facade;
-		if (!facade) return;
-		this.valueChangedUnsub = facade.on("valueChanged", (event) => {
-			if (event.device !== this.address) return;
-			this.handleValueChanged(event);
-		});
-	}
-	/**
-	* Translate an inbound facade `valueChanged` into the relevant cap
-	* slice, keyed by parameter name. Only updates caps the device
-	* actually registered (`capChannels`).
-	*/
-	handleValueChanged(event) {
-		const now = event.ts || Date.now();
-		const { parameter, value } = event;
-		if (this.capChannels.has("switch") && parameter === "STATE" && typeof value === "boolean") this.runtimeState.setCapState("switch", {
-			on: value,
-			lastChangedAt: now
-		});
-		if (this.capChannels.has("cover")) {
-			const next = require_addon.decodeCover(this.runtimeState.getCapState("cover") ?? COLD_COVER, parameter, value, now);
-			if (next) this.runtimeState.setCapState("cover", next);
-		}
-		if (this.capChannels.has("lock-control")) {
-			const next = require_addon.decodeLock(parameter, value, now);
-			if (next) this.runtimeState.setCapState("lock-control", next);
-		}
-		if (this.capChannels.has("climate-control")) {
-			const next = require_addon.decodeClimate(this.runtimeState.getCapState("climate-control") ?? COLD_CLIMATE, parameter, value, now);
-			if (next) this.runtimeState.setCapState("climate-control", next);
-		}
-		if (this.capChannels.has("motion") && parameter === "MOTION" && typeof value === "boolean") this.runtimeState.setCapState("motion", {
-			detected: value,
-			lastDetectedAt: value ? now : this.runtimeState.getCapState("motion")?.lastDetectedAt ?? null,
-			autoClearAfterMs: null
-		});
-		if (this.eventTypes.length > 0) this.decodeKeyPress(event, now);
-		this.decodeSensorPush(parameter, value, now);
-	}
-	/**
-	* Translate a key-channel `PRESS_*` datapoint into an `EventFire`: emit
-	* `EventCategory.EventEmitted` on the bus and write the `event-emitter`
-	* slice. The `eventType` is the native datapoint name VERBATIM (no
-	* normalization); the button index (`:N` suffix of the channel address)
-	* travels in `data.channel`. Non-key datapoints and value resets (the
-	* key datapoint dropping back to `false`) are ignored.
-	*/
-	decodeKeyPress(event, now) {
-		const { parameter, value, channel } = event;
-		if (!HM_KEY_PRESS_SET.has(parameter)) return;
-		if (typeof value === "boolean" && value === false) return;
-		const channelIndex = channelIndexFromAddress(channel);
-		const fire = {
-			deviceId: this.id,
-			eventType: parameter,
-			data: channelIndex !== null ? { channel: channelIndex } : {},
-			timestamp: now,
-			seq: ++this.#eventSeq
-		};
-		this.ctx.eventBus.emit(require_addon.createEvent(require_addon.EventCategory.EventEmitted, {
-			type: "device",
-			id: this.stableId,
-			deviceId: this.id,
-			addonId: this.ctx.deviceMeta.addonId
-		}, fire));
-		const slice = {
-			eventTypes: [...this.eventTypes],
-			lastEvent: fire,
-			eventCountSinceStart: ++this.#eventCount
-		};
-		this.runtimeState.setCapState("event-emitter", slice);
-	}
-	/** Decode read-only sensor pushes into their slices. */
-	decodeSensorPush(parameter, value, now) {
-		if (typeof value !== "number") return;
-		if (this.capChannels.has("temperature-sensor") && parameter === "ACTUAL_TEMPERATURE") this.runtimeState.setCapState("temperature-sensor", {
-			temperature: value,
-			lastFetchedAt: now
-		});
-		if (this.capChannels.has("humidity-sensor") && parameter === "HUMIDITY") this.runtimeState.setCapState("humidity-sensor", {
-			humidity: value,
-			lastFetchedAt: now
-		});
-		if (this.capChannels.has("ambient-light-sensor") && parameter === "ILLUMINATION") this.runtimeState.setCapState("ambient-light-sensor", {
-			illuminance: Math.max(0, value),
-			lastFetchedAt: now
-		});
-		this.decodePowerPush(parameter, value, now);
-	}
-	/** Decode HmIP energy-meter parameters into the power-meter slice. */
-	decodePowerPush(parameter, value, now) {
-		if (!this.capChannels.has("power-meter")) return;
-		const prev = this.runtimeState.getCapState("power-meter") ?? { lastFetchedAt: 0 };
-		switch (parameter) {
-			case "POWER":
-				this.runtimeState.setCapState("power-meter", {
-					...prev,
-					power: value,
-					lastFetchedAt: now
-				});
-				return;
-			case "ENERGY_COUNTER":
-				this.runtimeState.setCapState("power-meter", {
-					...prev,
-					energy: value / 1e3,
-					lastFetchedAt: now
-				});
-				return;
-			case "VOLTAGE":
-				this.runtimeState.setCapState("power-meter", {
-					...prev,
-					voltage: value,
-					lastFetchedAt: now
-				});
-				return;
-			case "CURRENT":
-				this.runtimeState.setCapState("power-meter", {
-					...prev,
-					current: value / 1e3,
-					lastFetchedAt: now
-				});
-				return;
-			default: return;
-		}
-	}
-	/** Reject an operation the underlying HmIP hardware does not support. */
-	unsupported(surface) {
-		throw new Error(`HomematicDevice: ${surface} not supported (address=${this.address})`);
-	}
-	/** Narrow the optional facade to a present one or throw a clear error. */
-	requireFacade() {
-		const facade = this.facade;
-		if (!facade) throw new Error(`HomematicDevice: CCU connection unavailable (address=${this.address})`);
-		return facade;
-	}
-	async removeDevice() {
-		if (this.valueChangedUnsub) {
-			try {
-				this.valueChangedUnsub();
-			} catch {}
-			this.valueChangedUnsub = null;
-		}
-	}
-};
-require_addon.DeviceType.Container, require_addon.DeviceType.Switch, require_addon.DeviceType.Cover, require_addon.DeviceType.Thermostat, require_addon.DeviceType.Lock, require_addon.DeviceType.Sensor, require_addon.DeviceType.EventEmitter, require_addon.DeviceType.Update, require_addon.DeviceType.Generic;
-//#endregion
-exports.HomematicDevice = HomematicDevice;
 exports.HomematicProviderAddon = require_addon.HomematicProviderAddon;
 exports.buildConnectionFormSchema = require_addon.buildConnectionFormSchema;
+exports.connectionFromSettings = require_addon.connectionFromSettings;
 exports.deriveHmEntitySpecs = require_addon.deriveHmEntitySpecs;
-exports.homematicAddonConfigSchema = require_addon.homematicAddonConfigSchema;
 exports.homematicConfigSchema = require_addon.homematicConfigSchema;
-exports.homematicDeviceSchema = homematicDeviceSchema;
+exports.homematicGatewayDeviceSchema = require_addon.homematicGatewayDeviceSchema;
 exports.inferHmDeviceType = require_addon.inferHmDeviceType;
 exports.mapHmChannel = require_addon.mapHmChannel;
 exports.mapHmDeviceChannels = require_addon.mapHmDeviceChannels;