@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/ts/integrations/broadlink/broadlink.classes.integration.ts

@@ -1,97 +1,143 @@
-import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import * as plugins from '../../plugins.js';
 import { BaseIntegration } from '../../core/classes.baseintegration.js';
-import type { IIntegrationEntity, IIntegrationEvent, IIntegrationRuntime, IIntegrationSetupContext, IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
+import { NativeIntegrationOwner, type INativeSetupLease } from '../../core/classes.nativeintegrationowner.js';
+import type { IDeviceFeatureWriteRequest, IIntegrationEntity, IIntegrationRuntime, IIntegrationSetupContext,
+  IServiceCallRequest, IServiceCallResult } from '../../core/types.js';
 import { BroadlinkClient } from './broadlink.classes.client.js';
 import { BroadlinkConfigFlow } from './broadlink.classes.configflow.js';
 import { createBroadlinkDiscoveryDescriptor } from './broadlink.discovery.js';
-import { BroadlinkMapper } from './broadlink.mapper.js';
+import { BroadlinkSelectedMapper } from './broadlink.selected.mapper.js';
+import { readBroadlinkActions } from './broadlink.actions.js';
+import { broadlinkRecord, readBroadlinkSelection } from './broadlink.validation.js';
 import type { IBroadlinkConfig } from './broadlink.types.js';
 
+const refused = (messageArg: string): IServiceCallResult => ({ success: false, error: messageArg,
+  data: { outcome: 'not-sent', physicalEffectConfirmed: false } });
+
+export interface IBroadlinkIntegrationOptions {
+  readonly homeId?: string;
+  readonly capacity?: number;
+}
+
 export class BroadlinkIntegration extends BaseIntegration<IBroadlinkConfig> {
   public readonly domain = 'broadlink';
   public readonly displayName = 'Broadlink';
   public readonly status = 'control-runtime' as const;
   public readonly discoveryDescriptor = createBroadlinkDiscoveryDescriptor();
-  public readonly configFlow = new BroadlinkConfigFlow();
+  public readonly configFlow: BroadlinkConfigFlow;
   public readonly metadata = {
-    source: 'home-assistant/core',
-    upstreamPath: 'homeassistant/components/broadlink',
-    upstreamDomain: 'broadlink',
-    integrationType: 'device',
-    iotClass: 'local_polling',
-    requirements: ['broadlink==0.19.0'],
-    dependencies: [],
-    afterDependencies: [],
-    codeowners: ['@danielhiversen', '@felipediel', '@L-I-Am', '@eifinger'],
-    documentation: 'https://www.home-assistant.io/integrations/broadlink',
-    configFlow: true,
-    discovery: {
-      dhcp: true,
-      manual: true,
-      localHelloRecords: true,
-      note: 'Home Assistant uses python-broadlink UDP hello/auth. This native port recognizes DHCP/manual/local hello candidates; live UDP is an injected executor boundary.',
-    },
-    runtime: {
-      type: 'control-runtime',
-      polling: 'snapshot/manual',
-      services: ['remote.send_command', 'remote.learn_command', 'remote.delete_command', 'switch.turn_on', 'switch.turn_off', 'infrared.send_command', 'radio_frequency.send_command', 'broadlink.send_packet'],
-      liveUdpAuthImplemented: false,
-    },
-    localApi: {
-      implemented: [
-        'Broadlink DHCP/manual/local hello discovery candidate mapping',
-        'Config flow shape for host, MAC, device type, timeout, and optional snapshot JSON',
-        'Snapshot mapping for RM remote entities, Broadlink switch/outlet slots, custom IR/RF switches, and safe sensor keys',
-        'Packet encoding for Broadlink IR timings and 315/433 MHz RF timings',
-        'Explicit service command shapes for learned-code send/delete, learn IR/RF, send packet, switch power, IR, and RF commands',
-      ],
-      explicitUnsupported: [
-        'Native Broadlink UDP discovery broadcast from this package',
-        'Native Broadlink encrypted UDP auth/session transport',
-        'Claiming live packets were sent without an injected commandExecutor or transport.execute',
-      ],
-    },
+    integrationType: 'device', iotClass: 'local_polling',
+    runtime: { type: 'control-runtime', liveUdpAuthImplemented: true,
+      services: ['button.press', 'broadlink.send_ir'], physicalEffectConfirmed: false, hardwareVerified: false },
+    localApi: { supportedDeviceTypes: [0x2737, 0x51da], ownerConfiguredRawIrOnly: true,
+      cryptographicPeerTrust: false, learning: false, rf: false, retransmission: false },
   };
+  readonly #owner: NativeIntegrationOwner;
+
+  constructor(optionsArg: IBroadlinkIntegrationOptions = {}) {
+    super();
+    this.#owner = new NativeIntegrationOwner('broadlink', optionsArg);
+    this.configFlow = new BroadlinkConfigFlow(this.#owner.createFlowScope());
+  }
 
   public async setup(configArg: IBroadlinkConfig, contextArg: IIntegrationSetupContext): Promise<IIntegrationRuntime> {
-    void contextArg;
-    return new BroadlinkRuntime(new BroadlinkClient(configArg));
+    const config = broadlinkRecord(configArg, ['homeId', 'host', 'macAddress', 'deviceType', 'port',
+      'localAddress', 'timeoutMs', 'maxPendingOperations', 'name', 'actions']);
+    const selection = readBroadlinkSelection(config);
+    const actions = config.actions === undefined ? undefined : readBroadlinkActions(config.actions);
+    const captured: IBroadlinkConfig = { ...selection, actions: actions?.map((actionArg) => ({ ...actionArg })) };
+    return this.#owner.runSetup(contextArg, selection.homeId, async (leaseArg) => {
+      const client = new BroadlinkClient(captured, { ...leaseArg.context, abortSignal: leaseArg.signal });
+      leaseArg.own(() => client.retryCleanup());
+      await client.initialize();
+      leaseArg.assertOpen();
+      const runtime = new BroadlinkRuntime(client, leaseArg);
+      leaseArg.promoteToRuntime();
+      return runtime;
+    });
   }
 
-  public async destroy(): Promise<void> {}
+  public destroy(): Promise<void> { return this.#owner.close(); }
+  public retryCleanup(): Promise<void> { return this.#owner.retryCleanup(); }
 }
 
 export class HomeAssistantBroadlinkIntegration extends BroadlinkIntegration {}
 
 class BroadlinkRuntime implements IIntegrationRuntime {
-  public domain = 'broadlink';
-
-  constructor(private readonly client: BroadlinkClient) {}
+  public readonly domain = 'broadlink';
+  constructor(private readonly client: BroadlinkClient, private readonly lease: INativeSetupLease) {}
+  public isHealthy(): boolean { return this.client.isHealthy(); }
 
-  public async devices(): Promise<shxInterfaces.data.IDeviceDefinition[]> {
-    return BroadlinkMapper.toDevices(await this.client.getSnapshot());
+  public async devices(signalArg?: AbortSignal): Promise<plugins.shxInterfaces.data.IDeviceDefinition[]> {
+    return BroadlinkSelectedMapper.toDevices(await this.client.getSnapshot(signalArg));
   }
-
   public async entities(): Promise<IIntegrationEntity[]> {
-    return BroadlinkMapper.toEntities(await this.client.getSnapshot());
+    return BroadlinkSelectedMapper.toEntities(await this.client.getSnapshot());
   }
 
-  public async subscribe(handlerArg: (eventArg: IIntegrationEvent) => void): Promise<() => Promise<void>> {
-    const unsubscribe = this.client.onEvent((eventArg) => handlerArg(BroadlinkMapper.toIntegrationEvent(eventArg)));
-    return async () => unsubscribe();
+  public async callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
+    try {
+      const request = broadlinkRecord(requestArg, ['domain', 'service', 'target', 'data']);
+      const target = broadlinkRecord(request.target, ['entityId', 'deviceId']);
+      const snapshot = this.client.currentSnapshot;
+      const knownDeviceId = BroadlinkSelectedMapper.deviceId(snapshot.selection);
+      if (target.deviceId !== undefined && target.deviceId !== knownDeviceId) return refused('Broadlink service target is outside the selected home and bridge.');
+      if (request.domain === 'button' && request.service === 'press') {
+        if (request.data !== undefined) broadlinkRecord(request.data, []);
+        const action = snapshot.actions.find((actionArg) => BroadlinkSelectedMapper.entityId(snapshot.selection, actionArg.id) === target.entityId);
+        if (!action) return refused('Broadlink button press requires one known action entity.');
+        return this.transmit(action.id);
+      }
+      if (request.domain === 'broadlink' && request.service === 'send_ir') {
+        const data = broadlinkRecord(request.data, ['actionId']);
+        const action = snapshot.actions.find((actionArg) => actionArg.id === data.actionId);
+        if (target.deviceId !== knownDeviceId || !action
+          || target.entityId !== undefined && target.entityId !== BroadlinkSelectedMapper.entityId(snapshot.selection, action.id)) {
+          return refused('Broadlink IR service requires the known bridge and one configured action ID.');
+        }
+        return this.transmit(action.id);
+      }
+      return refused('Broadlink supports only configured button.press and broadlink.send_ir actions.');
+    } catch { return refused('Broadlink service request is invalid.'); }
   }
 
-  public async callService(requestArg: IServiceCallRequest): Promise<IServiceCallResult> {
-    const snapshot = await this.client.getSnapshot();
-    const command = BroadlinkMapper.commandForService(snapshot, requestArg);
-    if (!command) {
-      return { success: false, error: `Unsupported Broadlink service or target: ${requestArg.domain}.${requestArg.service}` };
-    }
-    const result = await this.client.sendCommand(command);
-    return { success: result.success, error: result.error, data: result.data };
+  public async writeFeature(requestArg: IDeviceFeatureWriteRequest, signalArg?: AbortSignal): Promise<IServiceCallResult> {
+    try {
+      const request = broadlinkRecord(requestArg, ['device', 'feature', 'value']);
+      const device = broadlinkRecord(request.device, ['id', 'integrationDomain', 'name', 'room', 'protocol', 'manufacturer',
+        'model', 'online', 'features', 'state', 'metadata']);
+      const metadata = broadlinkRecord(device.metadata, ['homeId', 'macAddress', 'deviceType', 'physicalEffectConfirmed',
+        'cryptographicPeerTrust', 'hardwareVerified']);
+      const feature = broadlinkRecord(request.feature, ['id', 'capability', 'name', 'readable', 'writable', 'unit']);
+      const snapshot = this.client.currentSnapshot;
+      const canonical = BroadlinkSelectedMapper.toDevices(snapshot)[0];
+      const current = canonical.features.find((featureArg) => featureArg.id === feature.id && featureArg.writable);
+      if (device.id !== canonical.id || device.integrationDomain !== 'broadlink' || device.protocol !== 'udp'
+        || metadata.homeId !== snapshot.selection.homeId || metadata.macAddress !== snapshot.selection.macAddress
+        || metadata.deviceType !== snapshot.selection.deviceType || !current
+        || feature.capability !== current.capability || feature.name !== current.name
+        || feature.readable !== false || feature.writable !== true || feature.unit !== undefined || request.value !== true) {
+        return refused('Broadlink feature write requires the canonical selected action and trigger value true.');
+      }
+      if (signalArg !== undefined && !(signalArg instanceof AbortSignal)) return refused('Broadlink cancellation requires an AbortSignal.');
+      return this.transmit(current.id.slice(3), signalArg);
+    } catch { return refused('Broadlink feature request is invalid.'); }
   }
 
-  public async destroy(): Promise<void> {
-    await this.client.destroy();
+  private async transmit(actionIdArg: string, signalArg?: AbortSignal): Promise<IServiceCallResult> {
+    if (!this.client.isHealthy()) return refused('Broadlink selected bridge is unavailable.');
+    try {
+      const receipt = await this.client.sendAction(actionIdArg, signalArg);
+      return { success: true, data: receipt };
+    } catch (error) {
+      if (error instanceof plugins.ecobridgeDeviceManager.BroadlinkProtocolError) return {
+        success: false, error: 'Broadlink IR transmission failed.',
+        data: { code: error.code, outcome: error.effectOutcome, physicalEffectConfirmed: false },
+      };
+      return { success: false, error: 'Broadlink IR transmission failed.',
+        data: { outcome: 'indeterminate', physicalEffectConfirmed: false } };
+    }
   }
+
+  public destroy(): Promise<void> { return this.lease.close(); }
 }

package/ts/integrations/broadlink/broadlink.mapper.ts

@@ -18,7 +18,7 @@ import {
 } from './broadlink.packet.js';
 import type {
   IBroadlinkCommand,
-  IBroadlinkConfig,
+  IBroadlinkOfflineConfig,
   IBroadlinkCustomSwitchConfig,
   IBroadlinkDevice,
   IBroadlinkEntityDescriptor,
@@ -38,8 +38,9 @@ interface IBroadlinkSwitchDefinition {
   custom?: IBroadlinkCustomSwitchConfig;
 }
 
+/** Explicit offline mapping helpers; these do not validate or execute live controls. */
 export class BroadlinkMapper {
-  public static toSnapshot(configArg: IBroadlinkConfig, connectedArg?: boolean, eventsArg: IBroadlinkEvent[] = []): IBroadlinkSnapshot {
+  public static toSnapshot(configArg: IBroadlinkOfflineConfig, connectedArg?: boolean, eventsArg: IBroadlinkEvent[] = []): IBroadlinkSnapshot {
     const source = configArg.snapshot;
     const primaryDevice = this.primaryDevice(configArg, source);
     const devices = this.uniqueDevices([
@@ -461,7 +462,7 @@ export class BroadlinkMapper {
     };
   }
 
-  private static primaryDevice(configArg: IBroadlinkConfig, sourceArg?: IBroadlinkSnapshot): IBroadlinkDevice | undefined {
+  private static primaryDevice(configArg: IBroadlinkOfflineConfig, sourceArg?: IBroadlinkSnapshot): IBroadlinkDevice | undefined {
     if (!configArg.host && !configArg.name && !configArg.macAddress && !configArg.mac && !configArg.type && !configArg.state && !configArg.sensors && !configArg.codes && !configArg.switches?.length) {
       return undefined;
     }
@@ -489,7 +490,7 @@ export class BroadlinkMapper {
     };
   }
 
-  private static devicesFromManualEntries(configArg: IBroadlinkConfig): IBroadlinkDevice[] {
+  private static devicesFromManualEntries(configArg: IBroadlinkOfflineConfig): IBroadlinkDevice[] {
     const devices: IBroadlinkDevice[] = [];
     for (const entry of configArg.manualEntries || []) {
       if (entry.snapshot?.devices) {

package/ts/integrations/broadlink/broadlink.selected.mapper.ts

@@ -0,0 +1,46 @@
+import * as plugins from '../../plugins.js';
+import type { IIntegrationEntity } from '../../core/types.js';
+import type { IBroadlinkSelectedSnapshot, IBroadlinkSelection } from './broadlink.types.js';
+
+/** Maps verified selected bridge observations, without inferring appliance state. */
+export class BroadlinkSelectedMapper {
+  public static deviceId(selectionArg: IBroadlinkSelection): string {
+    return `broadlink.${encodeURIComponent(selectionArg.homeId)}.${selectionArg.macAddress}`;
+  }
+
+  public static entityId(selectionArg: IBroadlinkSelection, actionIdArg: string): string {
+    return `button.${this.deviceId(selectionArg)}.${actionIdArg}`;
+  }
+
+  public static toDevices(snapshotArg: IBroadlinkSelectedSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[] {
+    return [{
+      id: this.deviceId(snapshotArg.selection), integrationDomain: 'broadlink',
+      name: snapshotArg.selection.name, protocol: 'udp', manufacturer: 'Broadlink',
+      model: snapshotArg.selection.deviceType === 0x2737 ? 'RM mini 3' : 'RM4 mini',
+      online: snapshotArg.available,
+      features: [
+        { id: 'connectivity', capability: 'sensor', name: 'Bridge connectivity', readable: true, writable: false },
+        { id: 'firmware', capability: 'sensor', name: 'Bridge firmware', readable: true, writable: false },
+        ...snapshotArg.actions.map((actionArg) => ({ id: `ir.${actionArg.id}`, capability: 'notification' as const,
+          name: actionArg.name, readable: false, writable: true })),
+      ],
+      state: [
+        { featureId: 'connectivity', value: snapshotArg.available ? 'online' : 'offline', updatedAt: snapshotArg.observedAt },
+        { featureId: 'firmware', value: snapshotArg.firmwareVersion, updatedAt: snapshotArg.observedAt },
+      ],
+      metadata: { homeId: snapshotArg.selection.homeId, macAddress: snapshotArg.selection.macAddress,
+        deviceType: snapshotArg.selection.deviceType, physicalEffectConfirmed: false,
+        cryptographicPeerTrust: false, hardwareVerified: false },
+    }];
+  }
+
+  public static toEntities(snapshotArg: IBroadlinkSelectedSnapshot): IIntegrationEntity[] {
+    return snapshotArg.actions.map((actionArg) => ({
+      id: this.entityId(snapshotArg.selection, actionArg.id),
+      uniqueId: this.entityId(snapshotArg.selection, actionArg.id), integrationDomain: 'broadlink',
+      deviceId: this.deviceId(snapshotArg.selection), platform: 'button', name: actionArg.name,
+      state: null, available: snapshotArg.available,
+      attributes: { actionId: actionArg.id, writable: true, readable: false, physicalEffectConfirmed: false },
+    }));
+  }
+}

package/ts/integrations/broadlink/broadlink.types.ts

@@ -114,11 +114,8 @@ export interface IBroadlinkDevice {
   metadata?: Record<string, unknown>;
 }
 
-export interface IBroadlinkTransport {
-  execute(commandArg: IBroadlinkCommand): Promise<IBroadlinkCommandResult | unknown>;
-}
-
-export interface IBroadlinkConfig {
+/** Pure offline snapshot/mapping input. It never creates a live runtime. */
+export interface IBroadlinkOfflineConfig {
   host?: string;
   port?: number;
   timeout?: number;
@@ -146,8 +143,51 @@ export interface IBroadlinkConfig {
   manualEntries?: IBroadlinkManualEntry[];
   snapshot?: IBroadlinkSnapshot;
   metadata?: Record<string, unknown>;
-  commandExecutor?: (commandArg: IBroadlinkCommand) => Promise<IBroadlinkCommandResult | unknown>;
-  transport?: IBroadlinkTransport;
+}
+
+export type TBroadlinkSelectedDeviceType = 0x2737 | 0x51da;
+
+export interface IBroadlinkIrAction {
+  id: string;
+  name: string;
+  /** Canonical base64 of an owner-supplied native type-0x26, repeat-zero IR packet. */
+  packetBase64: string;
+}
+
+export interface IBroadlinkConfig {
+  /** Must match the independently selected home in the trusted host context. */
+  homeId: string;
+  host: string;
+  macAddress: string;
+  deviceType: TBroadlinkSelectedDeviceType;
+  port?: number;
+  localAddress?: string;
+  timeoutMs?: number;
+  maxPendingOperations?: number;
+  name?: string;
+  /** Explicit owner actions need no store. Omit only to restore from an admitted encrypted scoped store. */
+  actions?: IBroadlinkIrAction[];
+}
+
+export interface IBroadlinkSelection {
+  readonly homeId: string;
+  readonly host: string;
+  readonly macAddress: string;
+  readonly deviceType: TBroadlinkSelectedDeviceType;
+  readonly port: number;
+  readonly localAddress?: string;
+  readonly timeoutMs: number;
+  readonly maxPendingOperations: number;
+  readonly name: string;
+}
+
+/** Contains observed bridge information and action labels, never IR bytes or keys. */
+export interface IBroadlinkSelectedSnapshot {
+  readonly selection: IBroadlinkSelection;
+  readonly available: boolean;
+  readonly firmwareVersion: number;
+  readonly observedAt: string;
+  readonly actions: ReadonlyArray<Readonly<Pick<IBroadlinkIrAction, 'id' | 'name'>>>;
 }
 
 export interface IBroadlinkSnapshot {
@@ -247,4 +287,4 @@ export interface IBroadlinkCandidateMetadata extends Record<string, unknown> {
   snapshot?: IBroadlinkSnapshot;
 }
 
-export type IHomeAssistantBroadlinkConfig = IBroadlinkConfig;
+export type IHomeAssistantBroadlinkConfig = IBroadlinkOfflineConfig;

package/ts/integrations/broadlink/broadlink.validation.ts

@@ -0,0 +1,66 @@
+import * as plugins from '../../plugins.js';
+import type { IBroadlinkSelection } from './broadlink.types.js';
+
+/** Reads only plain, enumerable data fields, without invoking caller accessors. */
+export const broadlinkRecord = (valueArg: unknown, allowedArg: ReadonlyArray<string>): Record<string, unknown> => {
+  if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)
+    || Object.getPrototypeOf(valueArg) !== Object.prototype) throw new TypeError('Broadlink requires a plain object.');
+  const captured: 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('Broadlink input contains unsupported fields or accessors.');
+    }
+    captured[key] = descriptor.value;
+  }
+  return captured;
+};
+
+export const broadlinkName = (valueArg: unknown, nameArg: string, maximumArg: number): string => {
+  if (typeof valueArg !== 'string' || valueArg.length < 1 || valueArg.length > maximumArg
+    || valueArg !== valueArg.trim() || /[\p{Cc}\p{Cs}]/u.test(valueArg)) {
+    throw new TypeError(`Broadlink ${nameArg} must be nonempty text without control characters, at most ${maximumArg} characters.`);
+  }
+  return valueArg;
+};
+
+const integer = (valueArg: unknown, nameArg: string, maximumArg: number): number => {
+  if (typeof valueArg !== 'number' || !Number.isSafeInteger(valueArg) || valueArg < 1 || valueArg > maximumArg) {
+    throw new RangeError(`Broadlink ${nameArg} must be an integer from 1 through ${maximumArg}.`);
+  }
+  return valueArg;
+};
+
+const selectedAddress = (valueArg: unknown): string => {
+  if (typeof valueArg !== 'string' || plugins.net.isIP(valueArg) !== 4) throw new TypeError('Broadlink requires an explicit private IPv4 address.');
+  const [first, second, , last] = valueArg.split('.').map(Number);
+  if (last === 0 || last === 255 || !(first === 10 || first === 127 || first === 172 && second >= 16 && second <= 31
+    || first === 192 && second === 168)) throw new TypeError('Broadlink requires a private unicast IPv4 address; loopback is reserved for local fixtures.');
+  return valueArg;
+};
+
+export const readBroadlinkSelection = (configArg: unknown): IBroadlinkSelection => {
+  const config = broadlinkRecord(configArg, ['homeId', 'host', 'macAddress', 'deviceType', 'port', 'localAddress',
+    'timeoutMs', 'maxPendingOperations', 'name', 'actions']);
+  const homeId = broadlinkName(config.homeId, 'homeId', 256);
+  if (typeof config.macAddress !== 'string' || !/^(?:[\da-f]{12}|[\da-f]{2}(?::[\da-f]{2}){5}|[\da-f]{2}(?:-[\da-f]{2}){5})$/i.test(config.macAddress)) {
+    throw new TypeError('Broadlink requires an exact six-byte MAC address.');
+  }
+  const macAddress = config.macAddress.replace(/[:-]/g, '').toLowerCase();
+  if (parseInt(macAddress.slice(0, 2), 16) & 1 || /^0{12}$/.test(macAddress)) throw new TypeError('Broadlink requires a nonzero unicast MAC address.');
+  if (config.deviceType !== 0x2737 && config.deviceType !== 0x51da) throw new TypeError('Broadlink supports only RM mini 3 type 0x2737 and RM4 mini type 0x51da.');
+  return Object.freeze({
+    homeId, host: selectedAddress(config.host), macAddress, deviceType: config.deviceType,
+    port: integer(config.port ?? 80, 'port', 65535),
+    localAddress: config.localAddress === undefined ? undefined : selectedAddress(config.localAddress),
+    timeoutMs: integer(config.timeoutMs ?? 5000, 'timeoutMs', 60000),
+    maxPendingOperations: integer(config.maxPendingOperations ?? 32, 'maxPendingOperations', 128),
+    name: config.name === undefined ? 'Broadlink IR bridge' : broadlinkName(config.name, 'name', 128),
+  });
+};
+
+export const broadlinkConfigKey = (selectionArg: IBroadlinkSelection): string => `bridge.${selectionArg.macAddress}`;
+
+export const sameBroadlinkSelection = (leftArg: IBroadlinkSelection, rightArg: IBroadlinkSelection): boolean =>
+  leftArg.homeId === rightArg.homeId && leftArg.host === rightArg.host && leftArg.macAddress === rightArg.macAddress
+  && leftArg.deviceType === rightArg.deviceType && leftArg.port === rightArg.port && leftArg.localAddress === rightArg.localAddress;