@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/ts/integrations/denonavr/denonavr.discovery.ts

@@ -1,239 +1,86 @@
 import { DiscoveryDescriptor } from '../../core/classes.discoverydescriptor.js';
 import type { IDiscoveryCandidate, IDiscoveryMatch, IDiscoveryMatcher, IDiscoveryValidator } from '../../core/types.js';
-import type { IDenonavrManualEntry, IDenonavrMdnsRecord, IDenonavrSsdpRecord } from './denonavr.types.js';
+import type { IDenonavrManualEntry, IDenonavrSsdpRecord } from './denonavr.types.js';
+import { denonavrDescription, denonavrHost, denonavrModel, denonavrRecord, denonavrUdn } from './denonavr.validation.js';
 
-const supportedManufacturers = ['denon', 'denon professional', 'marantz'];
-const supportedDeviceTypes = [
-  'urn:schemas-upnp-org:device:mediarenderer:1',
-  'urn:schemas-upnp-org:device:mediaserver:1',
-  'urn:schemas-denon-com:device:aiosdevice:1',
-];
-const ignoredModels = ['heos 1', 'heos 3', 'heos 5', 'heos 7'];
+const miss = (reason: string): IDiscoveryMatch => ({ matched: false, confidence: 'low', reason });
 
-export class DenonavrSsdpMatcher implements IDiscoveryMatcher<IDenonavrSsdpRecord> {
-  public id = 'denonavr-ssdp-match';
-  public source = 'ssdp' as const;
-  public description = 'Recognize Denon and Marantz AVR SSDP advertisements.';
-
-  public async matches(recordArg: IDenonavrSsdpRecord): Promise<IDiscoveryMatch> {
-    const st = header(recordArg, 'st') || recordArg.upnp?.deviceType;
-    const usn = header(recordArg, 'usn');
-    const location = header(recordArg, 'location');
-    const manufacturer = upnp(recordArg, 'manufacturer');
-    const model = cleanModel(upnp(recordArg, 'modelName'));
-    const serialNumber = upnp(recordArg, 'serialNumber') || upnp(recordArg, 'serial');
-    const friendlyName = upnp(recordArg, 'friendlyName');
-    const deviceType = upnp(recordArg, 'deviceType') || st;
-
-    const matchedManufacturer = isSupportedManufacturer(manufacturer);
-    const matchedType = Boolean(deviceType && supportedDeviceTypes.includes(deviceType.toLowerCase()));
-    const matchedUsn = Boolean(usn?.toLowerCase().includes('denon') || usn?.toLowerCase().includes('marantz'));
-
-    if (!matchedManufacturer && !matchedType && !matchedUsn) {
-      return { matched: false, confidence: 'low', reason: 'SSDP record is not a Denon/Marantz AVR.' };
-    }
-    if (isIgnoredModel(model)) {
-      return { matched: false, confidence: 'low', reason: 'SSDP record is a HEOS speaker, not an AVR.' };
-    }
-
-    const url = parseUrl(location);
-    const id = uniqueId(model, serialNumber) || stripUuid(usn);
-    return {
-      matched: true,
-      confidence: id && matchedManufacturer ? 'certain' : matchedManufacturer || matchedType ? 'high' : 'medium',
-      reason: 'SSDP record matches Denon/Marantz AVR metadata.',
-      normalizedDeviceId: id,
-      candidate: {
-        source: 'ssdp',
-        integrationDomain: 'denonavr',
-        id,
-        host: url?.hostname,
-        port: url?.port ? Number(url.port) : undefined,
-        name: friendlyName,
-        manufacturer: normalizedManufacturer(manufacturer),
-        model,
-        serialNumber,
-        metadata: { st, usn, location, deviceType },
-      },
-    };
-  }
+function strings(value: unknown): Record<string, unknown> {
+  const record = denonavrRecord(value);
+  if (Object.keys(record).length > 64 || Object.values(record).some((entry) => entry !== undefined && (typeof entry !== 'string' || entry.length > 2048))) throw new TypeError('DenonAVR discovery fields must be bounded strings.');
+  return record;
 }
 
-export class DenonavrMdnsMatcher implements IDiscoveryMatcher<IDenonavrMdnsRecord> {
-  public id = 'denonavr-mdns-match';
-  public source = 'mdns' as const;
-  public description = 'Recognize Denon and Marantz AVR mDNS advertisements.';
-
-  public async matches(recordArg: IDenonavrMdnsRecord): Promise<IDiscoveryMatch> {
-    const name = recordArg.name || '';
-    const type = recordArg.type || '';
-    const manufacturer = recordArg.txt?.manufacturer || recordArg.txt?.brand || recordArg.txt?.Manufacturer;
-    const model = cleanModel(recordArg.txt?.model || recordArg.txt?.modelName || recordArg.txt?.ModelName);
-    const serialNumber = recordArg.txt?.serial || recordArg.txt?.serialNumber || recordArg.txt?.SerialNumber;
-    const haystack = `${name} ${type} ${manufacturer || ''} ${model || ''}`.toLowerCase();
-    const matched = isSupportedManufacturer(manufacturer) || haystack.includes('denon') || haystack.includes('marantz');
+function field(record: Record<string, unknown>, name: string): string | undefined {
+  const matches = Object.keys(record).filter((key) => key.toLowerCase() === name.toLowerCase());
+  if (matches.length > 1) throw new TypeError('DenonAVR discovery contains duplicate fields.');
+  const value = matches.length ? record[matches[0]] : undefined;
+  return typeof value === 'string' ? value : undefined;
+}
 
-    if (!matched) {
-      return { matched: false, confidence: 'low', reason: 'mDNS record is not a Denon/Marantz advertisement.' };
-    }
-    if (isIgnoredModel(model)) {
-      return { matched: false, confidence: 'low', reason: 'mDNS record is a HEOS speaker, not an AVR.' };
-    }
+function candidate(host: unknown, description: unknown, udn: unknown, modelValue: unknown, manufacturer: unknown,
+  source: 'ssdp' | 'manual', name?: string): IDiscoveryMatch {
+  const address = denonavrHost(host);
+  const descriptionUrl = denonavrDescription(description, address);
+  const id = denonavrUdn(udn);
+  const model = denonavrModel(modelValue);
+  const expectedManufacturer = model.startsWith('AVR-') ? 'Denon' : 'Marantz';
+  if (manufacturer !== undefined && (typeof manufacturer !== 'string' || manufacturer.toLowerCase() !== expectedManufacturer.toLowerCase())) throw new TypeError('DenonAVR discovery manufacturer does not match the model profile.');
+  return { matched: true, confidence: 'medium', reason: 'Selected-receiver setup hint; fresh descriptor and receiver observations are required for admission.',
+    normalizedDeviceId: id, candidate: { source, integrationDomain: 'denonavr', id, host: address, name,
+      manufacturer: expectedManufacturer, model, metadata: { descriptionUrl, identityEvidence: 'unauthenticated-discovery-hint' } } };
+}
 
-    const id = uniqueId(model, serialNumber) || recordArg.txt?.id || name;
-    return {
-      matched: true,
-      confidence: serialNumber ? 'certain' : 'medium',
-      reason: 'mDNS record matches Denon/Marantz metadata.',
-      normalizedDeviceId: id,
-      candidate: {
-        source: 'mdns',
-        integrationDomain: 'denonavr',
-        id,
-        host: recordArg.host,
-        port: recordArg.port,
-        name,
-        manufacturer: normalizedManufacturer(manufacturer),
-        model,
-        serialNumber,
-        metadata: { mdnsName: name, mdnsType: type, txt: recordArg.txt },
-      },
-    };
+export class DenonavrSsdpMatcher implements IDiscoveryMatcher<IDenonavrSsdpRecord> {
+  public readonly id = 'denonavr-ssdp-match';
+  public readonly source = 'ssdp' as const;
+  public readonly description = 'Recognize explicitly described, documented Denon/Marantz receiver setup hints.';
+
+  public async matches(input: IDenonavrSsdpRecord): Promise<IDiscoveryMatch> {
+    try {
+      const record = denonavrRecord(input, ['st', 'usn', 'location', 'headers', 'upnp']);
+      const headers = record.headers === undefined ? {} : strings(record.headers);
+      const upnp = record.upnp === undefined ? {} : strings(record.upnp);
+      const location = record.location ?? field(headers, 'location');
+      if (typeof location !== 'string') return miss('Selected descriptor URL is missing.');
+      const url = new URL(location);
+      const udn = field(upnp, 'UDN');
+      const usn = record.usn ?? field(headers, 'usn');
+      if (typeof usn === 'string' && denonavrUdn(usn.split('::')[0]) !== denonavrUdn(udn)) return miss('SSDP and descriptor identities conflict.');
+      return candidate(url.hostname, location, udn, field(upnp, 'modelName'), field(upnp, 'manufacturer'), 'ssdp', field(upnp, 'friendlyName'));
+    } catch { return miss('SSDP record lacks an exact supported model and selected descriptor identity.'); }
   }
 }
 
 export class DenonavrManualMatcher implements IDiscoveryMatcher<IDenonavrManualEntry> {
-  public id = 'denonavr-manual-match';
-  public source = 'manual' as const;
-  public description = 'Recognize manual Denon/Marantz AVR setup entries.';
-
-  public async matches(inputArg: IDenonavrManualEntry): Promise<IDiscoveryMatch> {
-    const model = cleanModel(inputArg.model);
-    const matched = Boolean(
-      inputArg.host
-      || isSupportedManufacturer(inputArg.manufacturer)
-      || model?.toLowerCase().includes('denon')
-      || model?.toLowerCase().includes('marantz')
-      || inputArg.metadata?.denonavr
-    );
-    if (!matched) {
-      return { matched: false, confidence: 'low', reason: 'Manual entry does not contain Denon AVR setup hints.' };
-    }
-    const id = uniqueId(model, inputArg.serialNumber) || inputArg.id;
-    return {
-      matched: true,
-      confidence: inputArg.host ? 'high' : 'medium',
-      reason: 'Manual entry can start Denon AVR setup.',
-      normalizedDeviceId: id,
-      candidate: {
-        source: 'manual',
-        integrationDomain: 'denonavr',
-        id,
-        host: inputArg.host,
-        port: inputArg.port || 80,
-        name: inputArg.name,
-        manufacturer: normalizedManufacturer(inputArg.manufacturer),
-        model,
-        serialNumber: inputArg.serialNumber,
-        metadata: inputArg.metadata,
-      },
-    };
+  public readonly id = 'denonavr-manual-match';
+  public readonly source = 'manual' as const;
+  public async matches(input: IDenonavrManualEntry): Promise<IDiscoveryMatch> {
+    try {
+      const record = denonavrRecord(input, ['host', 'descriptionUrl', 'expectedUdn', 'id', 'name', 'manufacturer', 'model', 'metadata']);
+      const metadata = record.metadata === undefined ? {} : denonavrRecord(record.metadata, ['descriptionUrl']);
+      if (record.name !== undefined && typeof record.name !== 'string') return miss('Receiver name is invalid.');
+      const id = record.expectedUdn ?? record.id;
+      if (record.expectedUdn !== undefined && record.id !== undefined && denonavrUdn(record.expectedUdn) !== denonavrUdn(record.id)) return miss('Manual receiver identities conflict.');
+      return candidate(record.host, record.descriptionUrl ?? metadata.descriptionUrl, id, record.model, record.manufacturer,
+        'manual', typeof record.name === 'string' ? record.name : undefined);
+    } catch { return miss('Manual setup must select a supported model, private IP, descriptor URL and exact UDN.'); }
   }
 }
 
 export class DenonavrCandidateValidator implements IDiscoveryValidator {
-  public id = 'denonavr-candidate-validator';
-  public description = 'Validate Denon/Marantz AVR candidate metadata.';
-
-  public async validate(candidateArg: IDiscoveryCandidate): Promise<IDiscoveryMatch> {
-    const manufacturer = candidateArg.manufacturer?.toLowerCase() || '';
-    const model = candidateArg.model?.toLowerCase() || '';
-    const matched = candidateArg.integrationDomain === 'denonavr'
-      || isSupportedManufacturer(manufacturer)
-      || model.includes('denon')
-      || model.includes('marantz')
-      || model.includes('avr')
-      || model.includes('sr');
-    const rejected = isIgnoredModel(model);
-
-    return {
-      matched: matched && !rejected,
-      confidence: matched && !rejected && candidateArg.host ? 'high' : matched && !rejected ? 'medium' : 'low',
-      reason: rejected ? 'Candidate is a HEOS speaker, not an AVR.' : matched ? 'Candidate has Denon/Marantz AVR metadata.' : 'Candidate is not a Denon AVR.',
-      candidate: matched && !rejected ? candidateArg : undefined,
-      normalizedDeviceId: uniqueId(candidateArg.model, candidateArg.serialNumber) || candidateArg.id,
-    };
+  public readonly id = 'denonavr-candidate-validator';
+  public async validate(input: IDiscoveryCandidate): Promise<IDiscoveryMatch> {
+    try {
+      const record = denonavrRecord(input, ['source', 'integrationDomain', 'id', 'host', 'port', 'name', 'manufacturer', 'model', 'metadata']);
+      if (record.integrationDomain !== 'denonavr' || (record.source !== 'manual' && record.source !== 'ssdp')) return miss('Candidate does not belong to selected DenonAVR discovery.');
+      const metadata = denonavrRecord(record.metadata, ['descriptionUrl', 'identityEvidence']);
+      return candidate(record.host, metadata.descriptionUrl, record.id, record.model, record.manufacturer, record.source,
+        typeof record.name === 'string' ? record.name : undefined);
+    } catch { return miss('Candidate cannot satisfy selected DenonAVR setup.'); }
   }
 }
 
-export const createDenonavrDiscoveryDescriptor = (): DiscoveryDescriptor => {
-  return new DiscoveryDescriptor({ integrationDomain: 'denonavr', displayName: 'Denon AVR Network Receivers' })
-    .addMatcher(new DenonavrSsdpMatcher())
-    .addMatcher(new DenonavrMdnsMatcher())
-    .addMatcher(new DenonavrManualMatcher())
-    .addValidator(new DenonavrCandidateValidator());
-};
-
-const header = (recordArg: IDenonavrSsdpRecord, keyArg: string): string | undefined => {
-  return recordArg[keyArg as keyof IDenonavrSsdpRecord] as string | undefined
-    || valueForKey(recordArg.headers, keyArg);
-};
-
-const upnp = (recordArg: IDenonavrSsdpRecord, keyArg: string): string | undefined => {
-  return valueForKey(recordArg.upnp, keyArg) || valueForKey(recordArg.headers, keyArg);
-};
-
-const valueForKey = (recordArg: Record<string, string | undefined> | undefined, keyArg: string): string | undefined => {
-  if (!recordArg) {
-    return undefined;
-  }
-  const lowerKey = keyArg.toLowerCase();
-  for (const [key, value] of Object.entries(recordArg)) {
-    if (key.toLowerCase() === lowerKey) {
-      return value;
-    }
-  }
-  return undefined;
-};
-
-const parseUrl = (valueArg: string | undefined): URL | undefined => {
-  if (!valueArg) {
-    return undefined;
-  }
-  try {
-    return new URL(valueArg);
-  } catch {
-    return undefined;
-  }
-};
-
-const stripUuid = (valueArg: string | undefined): string | undefined => {
-  return valueArg?.replace(/^uuid:/i, '').split('::')[0];
-};
-
-const cleanModel = (valueArg: string | undefined): string | undefined => {
-  return valueArg?.replace(/\*/g, '').trim() || undefined;
-};
-
-const isSupportedManufacturer = (valueArg: string | undefined): boolean => {
-  const value = valueArg?.toLowerCase().trim();
-  return Boolean(value && supportedManufacturers.includes(value));
-};
-
-const normalizedManufacturer = (valueArg: string | undefined): string | undefined => {
-  if (!valueArg) {
-    return undefined;
-  }
-  return valueArg.toLowerCase().includes('marantz') ? 'Marantz' : valueArg.toLowerCase().includes('denon') ? 'Denon' : valueArg;
-};
-
-const isIgnoredModel = (valueArg: string | undefined): boolean => {
-  return Boolean(valueArg && ignoredModels.includes(valueArg.toLowerCase()));
-};
-
-const uniqueId = (modelArg: string | undefined, serialArg: string | undefined): string | undefined => {
-  if (modelArg && serialArg) {
-    return `${cleanModel(modelArg)}-${serialArg}`;
-  }
-  return serialArg;
-};
+export const createDenonavrDiscoveryDescriptor = (): DiscoveryDescriptor =>
+  new DiscoveryDescriptor({ integrationDomain: 'denonavr', displayName: 'Denon and Marantz selected receivers' })
+    .addMatcher(new DenonavrSsdpMatcher()).addMatcher(new DenonavrManualMatcher()).addValidator(new DenonavrCandidateValidator());

package/ts/integrations/denonavr/denonavr.mapper.ts

@@ -1,193 +1,47 @@
-import * as plugins from '../../plugins.js';
+import type * as plugins from '../../plugins.js';
 import type { IIntegrationEntity } from '../../core/types.js';
-import type { IDenonavrReceiverInfo, IDenonavrSnapshot, IDenonavrZoneState } from './denonavr.types.js';
+import type { IDenonavrSnapshot } from './denonavr.types.js';
 
 export class DenonavrMapper {
-  public static toDevices(snapshotArg: IDenonavrSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[] {
-    const updatedAt = new Date().toISOString();
-    const features: plugins.shxInterfaces.data.IDeviceFeature[] = [];
-    const state: plugins.shxInterfaces.data.IDeviceState[] = [];
-
-    for (const zone of snapshotArg.zones) {
-      const zoneSlug = this.slug(zone.zone);
-      features.push(
-        { id: `${zoneSlug}_power`, capability: 'media', name: `${this.zoneName(zone)} power`, readable: true, writable: true },
-        { id: `${zoneSlug}_source`, capability: 'media', name: `${this.zoneName(zone)} source`, readable: true, writable: true },
-        { id: `${zoneSlug}_volume`, capability: 'media', name: `${this.zoneName(zone)} volume`, readable: true, writable: true, unit: '%' },
-        { id: `${zoneSlug}_muted`, capability: 'media', name: `${this.zoneName(zone)} muted`, readable: true, writable: true },
-      );
-      state.push(
-        { featureId: `${zoneSlug}_power`, value: this.powerState(zone), updatedAt },
-        { featureId: `${zoneSlug}_source`, value: zone.source || null, updatedAt },
-        { featureId: `${zoneSlug}_volume`, value: typeof this.volumeLevel(zone) === 'number' ? Math.round((this.volumeLevel(zone) || 0) * 100) : null, updatedAt },
-        { featureId: `${zoneSlug}_muted`, value: zone.muted ?? null, updatedAt },
-      );
-      if (zone.soundMode || zone.soundModeRaw) {
-        features.push({ id: `${zoneSlug}_sound_mode`, capability: 'media', name: `${this.zoneName(zone)} sound mode`, readable: true, writable: true });
-        state.push({ featureId: `${zoneSlug}_sound_mode`, value: zone.soundMode || zone.soundModeRaw || null, updatedAt });
-      }
-    }
-
-    return [{
-      id: this.deviceId(snapshotArg),
-      integrationDomain: 'denonavr',
-      name: this.receiverName(snapshotArg.receiverInfo),
-      protocol: 'http',
-      manufacturer: snapshotArg.receiverInfo.manufacturer || 'Denon',
-      model: snapshotArg.receiverInfo.modelName || snapshotArg.receiverInfo.modelNumber,
-      online: snapshotArg.zones.some((zoneArg) => zoneArg.available !== false),
-      features,
-      state,
-      metadata: {
-        host: snapshotArg.receiverInfo.host,
-        port: snapshotArg.receiverInfo.port,
-        serialNumber: snapshotArg.receiverInfo.serialNumber,
-        receiverType: snapshotArg.receiverInfo.receiverType,
-        softwareVersion: snapshotArg.receiverInfo.softwareVersion,
-      },
-    }];
-  }
-
-  public static toEntities(snapshotArg: IDenonavrSnapshot): IIntegrationEntity[] {
-    const entities: IIntegrationEntity[] = [];
-    for (const zone of snapshotArg.zones) {
-      const zoneEntityBase = this.entityBase(snapshotArg, zone);
-      entities.push({
-        id: `media_player.${zoneEntityBase}`,
-        uniqueId: `denonavr_${this.uniqueBase(snapshotArg)}_${this.slug(zone.zone)}`,
-        integrationDomain: 'denonavr',
-        deviceId: this.deviceId(snapshotArg),
-        platform: 'media_player',
-        name: this.mediaEntityName(snapshotArg.receiverInfo, zone),
-        state: this.mediaState(zone),
-        attributes: {
-          deviceClass: 'receiver',
-          zone: zone.zone,
-          power: zone.power,
-          volumeLevel: this.volumeLevel(zone),
-          volumeDb: zone.volumeDb,
-          isVolumeMuted: zone.muted,
-          source: zone.source,
-          sourceList: zone.sourceList,
-          soundMode: zone.soundMode,
-          soundModeRaw: zone.soundModeRaw,
-          soundModeList: zone.soundModeList,
-          mediaTitle: zone.media?.title || (!zone.media ? zone.source : undefined),
-          mediaArtist: zone.media?.artist || zone.media?.band,
-          mediaAlbumName: zone.media?.album || zone.media?.station,
-          mediaImageUrl: zone.media?.imageUrl,
-          mediaContentType: zone.media?.contentType,
-          dynamicEq: zone.dynamicEq,
-          ecoMode: zone.ecoMode,
-        },
-        available: zone.available !== false,
-      });
-
-      entities.push({
-        id: `sensor.${zoneEntityBase}_source`,
-        uniqueId: `denonavr_${this.uniqueBase(snapshotArg)}_${this.slug(zone.zone)}_source`,
-        integrationDomain: 'denonavr',
-        deviceId: this.deviceId(snapshotArg),
-        platform: 'sensor',
-        name: `${this.mediaEntityName(snapshotArg.receiverInfo, zone)} Source`,
-        state: zone.source || 'unknown',
-        attributes: { zone: zone.zone, soundMode: zone.soundMode || zone.soundModeRaw, ecoMode: zone.ecoMode },
-        available: zone.available !== false,
-      });
-
-      if (typeof zone.muted === 'boolean') {
-        entities.push({
-          id: `switch.${zoneEntityBase}_mute`,
-          uniqueId: `denonavr_${this.uniqueBase(snapshotArg)}_${this.slug(zone.zone)}_mute`,
-          integrationDomain: 'denonavr',
-          deviceId: this.deviceId(snapshotArg),
-          platform: 'switch',
-          name: `${this.mediaEntityName(snapshotArg.receiverInfo, zone)} Mute`,
-          state: zone.muted,
-          attributes: { zone: zone.zone },
-          available: zone.available !== false,
-        });
-      }
-
-      if (typeof zone.dynamicEq === 'boolean') {
-        entities.push({
-          id: `switch.${zoneEntityBase}_dynamic_eq`,
-          uniqueId: `denonavr_${this.uniqueBase(snapshotArg)}_${this.slug(zone.zone)}_dynamic_eq`,
-          integrationDomain: 'denonavr',
-          deviceId: this.deviceId(snapshotArg),
-          platform: 'switch',
-          name: `${this.mediaEntityName(snapshotArg.receiverInfo, zone)} Dynamic EQ`,
-          state: zone.dynamicEq,
-          attributes: { zone: zone.zone },
-          available: zone.available !== false,
-        });
-      }
-    }
-    return entities;
-  }
-
-  private static mediaState(zoneArg: IDenonavrZoneState): string {
-    if (this.powerState(zoneArg) === 'off') {
-      return 'off';
-    }
-    const state = zoneArg.state?.toLowerCase();
-    if (state === 'playing' || state === 'paused') {
-      return state;
-    }
-    if (state === 'stopped') {
-      return 'idle';
-    }
-    return 'on';
+  public static deviceId(homeId: string, udn: string): string {
+    return `denonavr.receiver.${encodeURIComponent(homeId)}.${encodeURIComponent(udn)}`;
   }
 
-  private static powerState(zoneArg: IDenonavrZoneState): string {
-    const power = zoneArg.power?.toLowerCase();
-    if (power === 'off' || power === 'standby') {
-      return 'off';
-    }
-    if (!power && zoneArg.state?.toLowerCase() === 'off') {
-      return 'off';
-    }
-    return 'on';
+  public static entityId(homeId: string, udn: string): string {
+    return `media_player.denonavr.${encodeURIComponent(homeId)}.${encodeURIComponent(udn)}`;
   }
 
-  private static volumeLevel(zoneArg: IDenonavrZoneState): number | undefined {
-    if (typeof zoneArg.volumeLevel === 'number') {
-      return Math.max(0, Math.min(1, zoneArg.volumeLevel));
-    }
-    if (typeof zoneArg.volumeDb === 'number') {
-      return Math.max(0, Math.min(1, (zoneArg.volumeDb + 80) / 100));
-    }
-    return undefined;
-  }
-
-  private static deviceId(snapshotArg: IDenonavrSnapshot): string {
-    return `denonavr.receiver.${this.uniqueBase(snapshotArg)}`;
-  }
-
-  private static entityBase(snapshotArg: IDenonavrSnapshot, zoneArg: IDenonavrZoneState): string {
-    const suffix = zoneArg.zone === 'Main' ? '' : `_${this.slug(zoneArg.zone)}`;
-    return `${this.slug(this.receiverName(snapshotArg.receiverInfo))}${suffix}`;
-  }
-
-  private static uniqueBase(snapshotArg: IDenonavrSnapshot): string {
-    return this.slug(snapshotArg.receiverInfo.serialNumber || snapshotArg.receiverInfo.modelName || snapshotArg.receiverInfo.host || this.receiverName(snapshotArg.receiverInfo));
-  }
-
-  private static receiverName(infoArg: IDenonavrReceiverInfo): string {
-    return infoArg.name || infoArg.friendlyName || infoArg.modelName || 'Denon AVR';
-  }
-
-  private static mediaEntityName(infoArg: IDenonavrReceiverInfo, zoneArg: IDenonavrZoneState): string {
-    const name = zoneArg.name || this.zoneName(zoneArg);
-    return zoneArg.zone === 'Main' ? this.receiverName(infoArg) : `${this.receiverName(infoArg)} ${name}`;
-  }
-
-  private static zoneName(zoneArg: IDenonavrZoneState): string {
-    return zoneArg.name || (zoneArg.zone === 'Main' ? 'Main Zone' : zoneArg.zone);
+  public static toDevices(snapshot: IDenonavrSnapshot): plugins.shxInterfaces.data.IDeviceDefinition[] {
+    return [{
+      id: this.deviceId(snapshot.homeId, snapshot.identity.udn), integrationDomain: 'denonavr', name: snapshot.name,
+      protocol: 'tcp', manufacturer: snapshot.identity.manufacturer, model: snapshot.identity.model, online: true,
+      features: [
+        { id: 'power', capability: 'media', name: 'Receiver power', readable: true, writable: true },
+        { id: 'muted', capability: 'media', name: 'Main-zone mute', readable: true, writable: true },
+        { id: 'volume_db', capability: 'media', name: 'Main-zone absolute volume', unit: 'dB', readable: true, writable: true },
+        { id: 'input', capability: 'media', name: 'Main-zone input', readable: true, writable: snapshot.observedInputs.length > 0 },
+      ],
+      state: [
+        { featureId: 'power', value: snapshot.power === 'on', updatedAt: snapshot.observedAt },
+        { featureId: 'muted', value: snapshot.muted, updatedAt: snapshot.observedAt },
+        { featureId: 'volume_db', value: snapshot.volumeDb, updatedAt: snapshot.observedAt },
+        { featureId: 'input', value: snapshot.input, updatedAt: snapshot.observedAt },
+      ],
+      metadata: { homeId: snapshot.homeId, udn: snapshot.identity.udn, host: snapshot.host, port: snapshot.port,
+        serialNumber: snapshot.identity.serialNumber, identitySource: snapshot.identity.source,
+        observedInputs: [...snapshot.observedInputs], maximumVolumeDb: snapshot.maximumVolumeDb,
+        stateSource: 'receiver-observation', identityAuthentication: 'unauthenticated-lan' },
+    }];
   }
 
-  private static slug(valueArg: string): string {
-    return valueArg.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'denonavr';
+  public static toEntities(snapshot: IDenonavrSnapshot): IIntegrationEntity[] {
+    return [{
+      id: this.entityId(snapshot.homeId, snapshot.identity.udn), uniqueId: this.deviceId(snapshot.homeId, snapshot.identity.udn),
+      integrationDomain: 'denonavr', deviceId: this.deviceId(snapshot.homeId, snapshot.identity.udn), platform: 'media_player',
+      name: snapshot.name, state: snapshot.power === 'on' ? 'on' : 'off', available: true,
+      attributes: { homeId: snapshot.homeId, udn: snapshot.identity.udn, zone: 'Main', power: snapshot.power,
+        volumeDb: snapshot.volumeDb, muted: snapshot.muted, source: snapshot.input, sourceList: [...snapshot.observedInputs],
+        maximumVolumeDb: snapshot.maximumVolumeDb, observedAt: snapshot.observedAt, stateSource: 'receiver-observation' },
+    }];
   }
 }