Add native local controller integrations

ts/index.ts

@@ -2,18 +2,48 @@ export * from './core/index.js';
 export * from './protocols/index.js';
 export * from './integrations/index.js';
 
+import { AcaiaIntegration } from './integrations/acaia/index.js';
+import { AcerProjectorIntegration } from './integrations/acer_projector/index.js';
+import { AcmedaIntegration } from './integrations/acmeda/index.js';
+import { ActiontecIntegration } from './integrations/actiontec/index.js';
+import { AdaxIntegration } from './integrations/adax/index.js';
 import { AdguardIntegration } from './integrations/adguard/index.js';
+import { AdsIntegration } from './integrations/ads/index.js';
+import { AdvantageAirIntegration } from './integrations/advantage_air/index.js';
 import { AgentDvrIntegration } from './integrations/agent_dvr/index.js';
 import { AirgradientIntegration } from './integrations/airgradient/index.js';
+import { AirobotIntegration } from './integrations/airobot/index.js';
 import { AirosIntegration } from './integrations/airos/index.js';
+import { AirqIntegration } from './integrations/airq/index.js';
+import { AirthingsBleIntegration } from './integrations/airthings_ble/index.js';
+import { Airtouch4Integration } from './integrations/airtouch4/index.js';
+import { Airtouch5Integration } from './integrations/airtouch5/index.js';
+import { AirvisualProIntegration } from './integrations/airvisual_pro/index.js';
+import { AirzoneIntegration } from './integrations/airzone/index.js';
+import { AlarmdecoderIntegration } from './integrations/alarmdecoder/index.js';
 import { AmcrestIntegration } from './integrations/amcrest/index.js';
 import { AndroidIpWebcamIntegration } from './integrations/android_ip_webcam/index.js';
 import { AndroidtvIntegration } from './integrations/androidtv/index.js';
 import { AndroidtvRemoteIntegration } from './integrations/androidtv_remote/index.js';
+import { AnelPwrctrlIntegration } from './integrations/anel_pwrctrl/index.js';
+import { AnthemavIntegration } from './integrations/anthemav/index.js';
 import { ApcupsdIntegration } from './integrations/apcupsd/index.js';
+import { AppleTvIntegration } from './integrations/apple_tv/index.js';
+import { AprilaireIntegration } from './integrations/aprilaire/index.js';
+import { ApsystemsIntegration } from './integrations/apsystems/index.js';
+import { AqualogicIntegration } from './integrations/aqualogic/index.js';
+import { AquostvIntegration } from './integrations/aquostv/index.js';
+import { AranetIntegration } from './integrations/aranet/index.js';
 import { ArcamFmjIntegration } from './integrations/arcam_fmj/index.js';
+import { ArestIntegration } from './integrations/arest/index.js';
+import { ArrisTg2492lgIntegration } from './integrations/arris_tg2492lg/index.js';
+import { ArubaIntegration } from './integrations/aruba/index.js';
 import { AsuswrtIntegration } from './integrations/asuswrt/index.js';
+import { AtagIntegration } from './integrations/atag/index.js';
+import { AtenPeIntegration } from './integrations/aten_pe/index.js';
+import { AuroraAbbPoweroneIntegration } from './integrations/aurora_abb_powerone/index.js';
 import { AxisIntegration } from './integrations/axis/index.js';
+import { BafIntegration } from './integrations/baf/index.js';
 import { BleboxIntegration } from './integrations/blebox/index.js';
 import { BluesoundIntegration } from './integrations/bluesound/index.js';
 import { BluetoothLeTrackerIntegration } from './integrations/bluetooth_le_tracker/index.js';
@@ -143,18 +173,48 @@ import { generatedHomeAssistantPortIntegrations } from './integrations/generated
 import { IntegrationRegistry } from './core/index.js';
 
 export const integrations = [
+  new AcaiaIntegration(),
+  new AcerProjectorIntegration(),
+  new AcmedaIntegration(),
+  new ActiontecIntegration(),
+  new AdaxIntegration(),
   new AdguardIntegration(),
+  new AdsIntegration(),
+  new AdvantageAirIntegration(),
   new AgentDvrIntegration(),
   new AirgradientIntegration(),
+  new AirobotIntegration(),
   new AirosIntegration(),
+  new AirqIntegration(),
+  new AirthingsBleIntegration(),
+  new Airtouch4Integration(),
+  new Airtouch5Integration(),
+  new AirvisualProIntegration(),
+  new AirzoneIntegration(),
+  new AlarmdecoderIntegration(),
   new AmcrestIntegration(),
   new AndroidIpWebcamIntegration(),
   new AndroidtvIntegration(),
   new AndroidtvRemoteIntegration(),
+  new AnelPwrctrlIntegration(),
+  new AnthemavIntegration(),
   new ApcupsdIntegration(),
+  new AppleTvIntegration(),
+  new AprilaireIntegration(),
+  new ApsystemsIntegration(),
+  new AqualogicIntegration(),
+  new AquostvIntegration(),
+  new AranetIntegration(),
   new ArcamFmjIntegration(),
+  new ArestIntegration(),
+  new ArrisTg2492lgIntegration(),
+  new ArubaIntegration(),
   new AsuswrtIntegration(),
+  new AtagIntegration(),
+  new AtenPeIntegration(),
+  new AuroraAbbPoweroneIntegration(),
   new AxisIntegration(),
+  new BafIntegration(),
   new BleboxIntegration(),
   new BluesoundIntegration(),
   new BluetoothLeTrackerIntegration(),

ts/integrations/acaia/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/acaia/acaia.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAcaiaConfig } from './acaia.types.js';
+import { acaiaProfile } from './acaia.types.js';
+
+export class AcaiaClient extends SimpleLocalClient<IAcaiaConfig> {
+  constructor(configArg: IAcaiaConfig) {
+    super(acaiaProfile, configArg);
+  }
+}

ts/integrations/acaia/acaia.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAcaiaConfig } from './acaia.types.js';
+import { acaiaProfile } from './acaia.types.js';
+
+export class AcaiaConfigFlow extends SimpleLocalConfigFlow<IAcaiaConfig> {
+  constructor() {
+    super(acaiaProfile);
+  }
+}

ts/integrations/acaia/acaia.classes.integration.ts

@@ -1,29 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AcaiaConfigFlow } from './acaia.classes.configflow.js';
+import { createAcaiaDiscoveryDescriptor } from './acaia.discovery.js';
+import type { IAcaiaConfig } from './acaia.types.js';
+import { acaiaDomain, acaiaProfile } from './acaia.types.js';
+
+export class AcaiaIntegration extends SimpleLocalIntegration<IAcaiaConfig> {
+  public readonly domain = acaiaDomain;
+  public readonly discoveryDescriptor = createAcaiaDiscoveryDescriptor();
+  public readonly configFlow = new AcaiaConfigFlow();
 
-export class HomeAssistantAcaiaIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "acaia",
-      displayName: "Acaia",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/acaia",
-  "upstreamDomain": "acaia",
-  "integrationType": "device",
-  "iotClass": "local_push",
-  "qualityScale": "platinum",
-  "requirements": [
-    "aioacaia==0.1.17"
-  ],
-  "dependencies": [
-    "bluetooth_adapters"
-  ],
-  "afterDependencies": [],
-  "codeowners": [
-    "@zweckj"
-  ]
-},
-    });
+    super(acaiaProfile);
   }
 }
+
+export class HomeAssistantAcaiaIntegration extends AcaiaIntegration {}

ts/integrations/acaia/acaia.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { acaiaProfile } from './acaia.types.js';
+
+export const createAcaiaDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(acaiaProfile);

ts/integrations/acaia/acaia.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAcaiaConfig } from './acaia.types.js';
+import { acaiaProfile } from './acaia.types.js';
+
+export class AcaiaMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAcaiaConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: acaiaProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAcaiaConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: acaiaProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(acaiaProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(acaiaProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/acaia/acaia.types.ts

@@ -1,4 +1,81 @@
-export interface IHomeAssistantAcaiaConfig {
-  // TODO: replace with the TypeScript-native config for acaia.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const acaiaDomain = "acaia";
+export const acaiaDefaultName = "Acaia";
+
+export type TAcaiaRawData = TSimpleLocalRawData;
+export interface IAcaiaSnapshot extends ISimpleLocalSnapshot {}
+export interface IAcaiaConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAcaiaConfig extends IAcaiaConfig {}
+
+export const acaiaProfile: ISimpleLocalIntegrationProfile = {
+  domain: "acaia",
+  displayName: "Acaia",
+  manufacturer: "Acaia",
+  model: "Bluetooth scale",
+  defaultName: "Acaia",
+  defaultProtocol: "local",
+  status: "read-only-runtime",
+  platforms: [
+    "sensor",
+    "binary_sensor"
+  ],
+  serviceDomains: [],
+  controlServices: [],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "acaia",
+    "scale",
+    "bluetooth"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/acaia",
+    upstreamDomain: "acaia",
+    integrationType: "device",
+    iotClass: "local_push",
+    qualityScale: "platinum",
+    requirements: [
+      "aioacaia==0.1.17"
+    ],
+    dependencies: [
+      "bluetooth_adapters"
+    ],
+    afterDependencies: [],
+    codeowners: [
+      "@Bluetooth-Devices"
+    ],
+    configFlow: true,
+    runtime: {
+      type: "read-only-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh"
+      ],
+      platforms: [
+        "sensor",
+        "binary_sensor"
+      ],
+      controls: false
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/acaia/index.ts

@@ -1,2 +1,6 @@
+export * from './acaia.classes.client.js';
+export * from './acaia.classes.configflow.js';
 export * from './acaia.classes.integration.js';
+export * from './acaia.discovery.js';
+export * from './acaia.mapper.js';
 export * from './acaia.types.js';

ts/integrations/acer_projector/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/acer_projector/acer_projector.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAcerProjectorConfig } from './acer_projector.types.js';
+import { acerProjectorProfile } from './acer_projector.types.js';
+
+export class AcerProjectorClient extends SimpleLocalClient<IAcerProjectorConfig> {
+  constructor(configArg: IAcerProjectorConfig) {
+    super(acerProjectorProfile, configArg);
+  }
+}

ts/integrations/acer_projector/acer_projector.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAcerProjectorConfig } from './acer_projector.types.js';
+import { acerProjectorProfile } from './acer_projector.types.js';
+
+export class AcerProjectorConfigFlow extends SimpleLocalConfigFlow<IAcerProjectorConfig> {
+  constructor() {
+    super(acerProjectorProfile);
+  }
+}

ts/integrations/acer_projector/acer_projector.classes.integration.ts

@@ -1,24 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AcerProjectorConfigFlow } from './acer_projector.classes.configflow.js';
+import { createAcerProjectorDiscoveryDescriptor } from './acer_projector.discovery.js';
+import type { IAcerProjectorConfig } from './acer_projector.types.js';
+import { acerProjectorDomain, acerProjectorProfile } from './acer_projector.types.js';
+
+export class AcerProjectorIntegration extends SimpleLocalIntegration<IAcerProjectorConfig> {
+  public readonly domain = acerProjectorDomain;
+  public readonly discoveryDescriptor = createAcerProjectorDiscoveryDescriptor();
+  public readonly configFlow = new AcerProjectorConfigFlow();
 
-export class HomeAssistantAcerProjectorIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "acer_projector",
-      displayName: "Acer Projector",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/acer_projector",
-  "upstreamDomain": "acer_projector",
-  "iotClass": "local_polling",
-  "qualityScale": "legacy",
-  "requirements": [
-    "serialx==1.4.1"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": []
-},
-    });
+    super(acerProjectorProfile);
   }
 }
+
+export class HomeAssistantAcerProjectorIntegration extends AcerProjectorIntegration {}

ts/integrations/acer_projector/acer_projector.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { acerProjectorProfile } from './acer_projector.types.js';
+
+export const createAcerProjectorDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(acerProjectorProfile);

ts/integrations/acer_projector/acer_projector.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAcerProjectorConfig } from './acer_projector.types.js';
+import { acerProjectorProfile } from './acer_projector.types.js';
+
+export class AcerProjectorMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAcerProjectorConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: acerProjectorProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAcerProjectorConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: acerProjectorProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(acerProjectorProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(acerProjectorProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/acer_projector/acer_projector.types.ts

@@ -1,4 +1,100 @@
-export interface IHomeAssistantAcerProjectorConfig {
-  // TODO: replace with the TypeScript-native config for acer_projector.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const acerProjectorDomain = "acer_projector";
+export const acerProjectorDefaultName = "Acer Projector";
+
+export type TAcerProjectorRawData = TSimpleLocalRawData;
+export interface IAcerProjectorSnapshot extends ISimpleLocalSnapshot {}
+export interface IAcerProjectorConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAcerProjectorConfig extends IAcerProjectorConfig {}
+
+export const acerProjectorProfile: ISimpleLocalIntegrationProfile = {
+  domain: "acer_projector",
+  displayName: "Acer Projector",
+  manufacturer: "Acer",
+  model: "Projector",
+  defaultName: "Acer Projector",
+  defaultProtocol: "local",
+  status: "control-runtime",
+  platforms: [
+    "media_player",
+    "sensor"
+  ],
+  serviceDomains: [
+    "media_player"
+  ],
+  controlServices: [
+    "turn_on",
+    "turn_off",
+    "volume_up",
+    "volume_down",
+    "volume_mute",
+    "select_source",
+    "media_play",
+    "media_pause",
+    "media_stop",
+    "media_next_track",
+    "media_previous_track"
+  ],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "acer",
+    "projector"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/acer_projector",
+    upstreamDomain: "acer_projector",
+    iotClass: "local_polling",
+    qualityScale: "legacy",
+    requirements: [
+      "serialx==1.4.1"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "control-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh",
+        "turn_on",
+        "turn_off",
+        "volume_up",
+        "volume_down",
+        "volume_mute",
+        "select_source",
+        "media_play",
+        "media_pause",
+        "media_stop",
+        "media_next_track",
+        "media_previous_track"
+      ],
+      platforms: [
+        "media_player",
+        "sensor"
+      ],
+      controls: true
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/acer_projector/index.ts

@@ -1,2 +1,6 @@
+export * from './acer_projector.classes.client.js';
+export * from './acer_projector.classes.configflow.js';
 export * from './acer_projector.classes.integration.js';
+export * from './acer_projector.discovery.js';
+export * from './acer_projector.mapper.js';
 export * from './acer_projector.types.js';

ts/integrations/acmeda/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/acmeda/acmeda.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAcmedaConfig } from './acmeda.types.js';
+import { acmedaProfile } from './acmeda.types.js';
+
+export class AcmedaClient extends SimpleLocalClient<IAcmedaConfig> {
+  constructor(configArg: IAcmedaConfig) {
+    super(acmedaProfile, configArg);
+  }
+}

ts/integrations/acmeda/acmeda.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAcmedaConfig } from './acmeda.types.js';
+import { acmedaProfile } from './acmeda.types.js';
+
+export class AcmedaConfigFlow extends SimpleLocalConfigFlow<IAcmedaConfig> {
+  constructor() {
+    super(acmedaProfile);
+  }
+}

ts/integrations/acmeda/acmeda.classes.integration.ts

@@ -1,25 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AcmedaConfigFlow } from './acmeda.classes.configflow.js';
+import { createAcmedaDiscoveryDescriptor } from './acmeda.discovery.js';
+import type { IAcmedaConfig } from './acmeda.types.js';
+import { acmedaDomain, acmedaProfile } from './acmeda.types.js';
+
+export class AcmedaIntegration extends SimpleLocalIntegration<IAcmedaConfig> {
+  public readonly domain = acmedaDomain;
+  public readonly discoveryDescriptor = createAcmedaDiscoveryDescriptor();
+  public readonly configFlow = new AcmedaConfigFlow();
 
-export class HomeAssistantAcmedaIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "acmeda",
-      displayName: "Rollease Acmeda Automate",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/acmeda",
-  "upstreamDomain": "acmeda",
-  "iotClass": "local_push",
-  "requirements": [
-    "aiopulse==0.4.6"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": [
-    "@atmurray"
-  ]
-},
-    });
+    super(acmedaProfile);
   }
 }
+
+export class HomeAssistantAcmedaIntegration extends AcmedaIntegration {}

ts/integrations/acmeda/acmeda.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { acmedaProfile } from './acmeda.types.js';
+
+export const createAcmedaDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(acmedaProfile);

ts/integrations/acmeda/acmeda.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAcmedaConfig } from './acmeda.types.js';
+import { acmedaProfile } from './acmeda.types.js';
+
+export class AcmedaMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAcmedaConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: acmedaProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAcmedaConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: acmedaProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(acmedaProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(acmedaProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/acmeda/acmeda.types.ts

@@ -1,4 +1,87 @@
-export interface IHomeAssistantAcmedaConfig {
-  // TODO: replace with the TypeScript-native config for acmeda.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const acmedaDomain = "acmeda";
+export const acmedaDefaultName = "Rollease Acmeda Automate";
+
+export type TAcmedaRawData = TSimpleLocalRawData;
+export interface IAcmedaSnapshot extends ISimpleLocalSnapshot {}
+export interface IAcmedaConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAcmedaConfig extends IAcmedaConfig {}
+
+export const acmedaProfile: ISimpleLocalIntegrationProfile = {
+  domain: "acmeda",
+  displayName: "Rollease Acmeda Automate",
+  manufacturer: "Rollease Acmeda",
+  model: "Automate Pulse",
+  defaultName: "Rollease Acmeda Automate",
+  defaultProtocol: "local",
+  status: "control-runtime",
+  platforms: [
+    "cover",
+    "sensor"
+  ],
+  serviceDomains: [
+    "cover"
+  ],
+  controlServices: [
+    "open_cover",
+    "close_cover",
+    "stop_cover",
+    "set_cover_position"
+  ],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "rollease",
+    "acmeda",
+    "automate",
+    "pulse"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/acmeda",
+    upstreamDomain: "acmeda",
+    iotClass: "local_push",
+    requirements: [
+      "aiopulse==0.4.6"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "control-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh",
+        "open_cover",
+        "close_cover",
+        "stop_cover",
+        "set_cover_position"
+      ],
+      platforms: [
+        "cover",
+        "sensor"
+      ],
+      controls: true
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/acmeda/index.ts

@@ -1,2 +1,6 @@
+export * from './acmeda.classes.client.js';
+export * from './acmeda.classes.configflow.js';
 export * from './acmeda.classes.integration.js';
+export * from './acmeda.discovery.js';
+export * from './acmeda.mapper.js';
 export * from './acmeda.types.js';

ts/integrations/actiontec/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/actiontec/actiontec.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IActiontecConfig } from './actiontec.types.js';
+import { actiontecProfile } from './actiontec.types.js';
+
+export class ActiontecClient extends SimpleLocalClient<IActiontecConfig> {
+  constructor(configArg: IActiontecConfig) {
+    super(actiontecProfile, configArg);
+  }
+}

ts/integrations/actiontec/actiontec.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IActiontecConfig } from './actiontec.types.js';
+import { actiontecProfile } from './actiontec.types.js';
+
+export class ActiontecConfigFlow extends SimpleLocalConfigFlow<IActiontecConfig> {
+  constructor() {
+    super(actiontecProfile);
+  }
+}

ts/integrations/actiontec/actiontec.classes.integration.ts

@@ -1,22 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { ActiontecConfigFlow } from './actiontec.classes.configflow.js';
+import { createActiontecDiscoveryDescriptor } from './actiontec.discovery.js';
+import type { IActiontecConfig } from './actiontec.types.js';
+import { actiontecDomain, actiontecProfile } from './actiontec.types.js';
+
+export class ActiontecIntegration extends SimpleLocalIntegration<IActiontecConfig> {
+  public readonly domain = actiontecDomain;
+  public readonly discoveryDescriptor = createActiontecDiscoveryDescriptor();
+  public readonly configFlow = new ActiontecConfigFlow();
 
-export class HomeAssistantActiontecIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "actiontec",
-      displayName: "Actiontec",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/actiontec",
-  "upstreamDomain": "actiontec",
-  "iotClass": "local_polling",
-  "qualityScale": "legacy",
-  "requirements": [],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": []
-},
-    });
+    super(actiontecProfile);
   }
 }
+
+export class HomeAssistantActiontecIntegration extends ActiontecIntegration {}

ts/integrations/actiontec/actiontec.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { actiontecProfile } from './actiontec.types.js';
+
+export const createActiontecDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(actiontecProfile);

ts/integrations/actiontec/actiontec.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IActiontecConfig } from './actiontec.types.js';
+import { actiontecProfile } from './actiontec.types.js';
+
+export class ActiontecMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IActiontecConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: actiontecProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IActiontecConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: actiontecProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(actiontecProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(actiontecProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/actiontec/actiontec.types.ts

@@ -1,4 +1,74 @@
-export interface IHomeAssistantActiontecConfig {
-  // TODO: replace with the TypeScript-native config for actiontec.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const actiontecDomain = "actiontec";
+export const actiontecDefaultName = "Actiontec";
+
+export type TActiontecRawData = TSimpleLocalRawData;
+export interface IActiontecSnapshot extends ISimpleLocalSnapshot {}
+export interface IActiontecConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantActiontecConfig extends IActiontecConfig {}
+
+export const actiontecProfile: ISimpleLocalIntegrationProfile = {
+  domain: "actiontec",
+  displayName: "Actiontec",
+  manufacturer: "Actiontec",
+  model: "Router",
+  defaultName: "Actiontec",
+  defaultPort: 80,
+  defaultProtocol: "http",
+  status: "read-only-runtime",
+  platforms: [
+    "sensor",
+    "binary_sensor"
+  ],
+  serviceDomains: [],
+  controlServices: [],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "actiontec",
+    "router"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/actiontec",
+    upstreamDomain: "actiontec",
+    iotClass: "local_polling",
+    qualityScale: "legacy",
+    requirements: [],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "read-only-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh"
+      ],
+      platforms: [
+        "sensor",
+        "binary_sensor"
+      ],
+      controls: false
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/actiontec/index.ts

@@ -1,2 +1,6 @@
+export * from './actiontec.classes.client.js';
+export * from './actiontec.classes.configflow.js';
 export * from './actiontec.classes.integration.js';
+export * from './actiontec.discovery.js';
+export * from './actiontec.mapper.js';
 export * from './actiontec.types.js';

ts/integrations/adax/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/adax/adax.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAdaxConfig } from './adax.types.js';
+import { adaxProfile } from './adax.types.js';
+
+export class AdaxClient extends SimpleLocalClient<IAdaxConfig> {
+  constructor(configArg: IAdaxConfig) {
+    super(adaxProfile, configArg);
+  }
+}

ts/integrations/adax/adax.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAdaxConfig } from './adax.types.js';
+import { adaxProfile } from './adax.types.js';
+
+export class AdaxConfigFlow extends SimpleLocalConfigFlow<IAdaxConfig> {
+  constructor() {
+    super(adaxProfile);
+  }
+}

ts/integrations/adax/adax.classes.integration.ts

@@ -1,27 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AdaxConfigFlow } from './adax.classes.configflow.js';
+import { createAdaxDiscoveryDescriptor } from './adax.discovery.js';
+import type { IAdaxConfig } from './adax.types.js';
+import { adaxDomain, adaxProfile } from './adax.types.js';
+
+export class AdaxIntegration extends SimpleLocalIntegration<IAdaxConfig> {
+  public readonly domain = adaxDomain;
+  public readonly discoveryDescriptor = createAdaxDiscoveryDescriptor();
+  public readonly configFlow = new AdaxConfigFlow();
 
-export class HomeAssistantAdaxIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "adax",
-      displayName: "Adax",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/adax",
-  "upstreamDomain": "adax",
-  "iotClass": "local_polling",
-  "requirements": [
-    "adax==0.4.0",
-    "Adax-local==0.3.0"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": [
-    "@danielhiversen",
-    "@lazytarget"
-  ]
-},
-    });
+    super(adaxProfile);
   }
 }
+
+export class HomeAssistantAdaxIntegration extends AdaxIntegration {}

ts/integrations/adax/adax.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { adaxProfile } from './adax.types.js';
+
+export const createAdaxDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(adaxProfile);

ts/integrations/adax/adax.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAdaxConfig } from './adax.types.js';
+import { adaxProfile } from './adax.types.js';
+
+export class AdaxMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAdaxConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: adaxProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAdaxConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: adaxProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(adaxProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(adaxProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/adax/adax.types.ts

@@ -1,4 +1,86 @@
-export interface IHomeAssistantAdaxConfig {
-  // TODO: replace with the TypeScript-native config for adax.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const adaxDomain = "adax";
+export const adaxDefaultName = "Adax";
+
+export type TAdaxRawData = TSimpleLocalRawData;
+export interface IAdaxSnapshot extends ISimpleLocalSnapshot {}
+export interface IAdaxConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAdaxConfig extends IAdaxConfig {}
+
+export const adaxProfile: ISimpleLocalIntegrationProfile = {
+  domain: "adax",
+  displayName: "Adax",
+  manufacturer: "Adax",
+  model: "Local heater",
+  defaultName: "Adax",
+  defaultProtocol: "local",
+  status: "control-runtime",
+  platforms: [
+    "climate",
+    "sensor"
+  ],
+  serviceDomains: [
+    "climate"
+  ],
+  controlServices: [
+    "set_temperature",
+    "set_hvac_mode",
+    "turn_on",
+    "turn_off"
+  ],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "adax",
+    "heater"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/adax",
+    upstreamDomain: "adax",
+    iotClass: "local_polling",
+    requirements: [
+      "adax==0.4.0",
+      "Adax-local==0.3.0"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "control-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh",
+        "set_temperature",
+        "set_hvac_mode",
+        "turn_on",
+        "turn_off"
+      ],
+      platforms: [
+        "climate",
+        "sensor"
+      ],
+      controls: true
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/adax/index.ts

@@ -1,2 +1,6 @@
+export * from './adax.classes.client.js';
+export * from './adax.classes.configflow.js';
 export * from './adax.classes.integration.js';
+export * from './adax.discovery.js';
+export * from './adax.mapper.js';
 export * from './adax.types.js';

ts/integrations/ads/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/ads/ads.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAdsConfig } from './ads.types.js';
+import { adsProfile } from './ads.types.js';
+
+export class AdsClient extends SimpleLocalClient<IAdsConfig> {
+  constructor(configArg: IAdsConfig) {
+    super(adsProfile, configArg);
+  }
+}

ts/integrations/ads/ads.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAdsConfig } from './ads.types.js';
+import { adsProfile } from './ads.types.js';
+
+export class AdsConfigFlow extends SimpleLocalConfigFlow<IAdsConfig> {
+  constructor() {
+    super(adsProfile);
+  }
+}

ts/integrations/ads/ads.classes.integration.ts

@@ -1,26 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AdsConfigFlow } from './ads.classes.configflow.js';
+import { createAdsDiscoveryDescriptor } from './ads.discovery.js';
+import type { IAdsConfig } from './ads.types.js';
+import { adsDomain, adsProfile } from './ads.types.js';
+
+export class AdsIntegration extends SimpleLocalIntegration<IAdsConfig> {
+  public readonly domain = adsDomain;
+  public readonly discoveryDescriptor = createAdsDiscoveryDescriptor();
+  public readonly configFlow = new AdsConfigFlow();
 
-export class HomeAssistantAdsIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "ads",
-      displayName: "ADS",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/ads",
-  "upstreamDomain": "ads",
-  "iotClass": "local_push",
-  "qualityScale": "legacy",
-  "requirements": [
-    "pyads==3.4.0"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": [
-    "@mrpasztoradam"
-  ]
-},
-    });
+    super(adsProfile);
   }
 }
+
+export class HomeAssistantAdsIntegration extends AdsIntegration {}

ts/integrations/ads/ads.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { adsProfile } from './ads.types.js';
+
+export const createAdsDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(adsProfile);

ts/integrations/ads/ads.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAdsConfig } from './ads.types.js';
+import { adsProfile } from './ads.types.js';
+
+export class AdsMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAdsConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: adsProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAdsConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: adsProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(adsProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(adsProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/ads/ads.types.ts

@@ -1,4 +1,89 @@
-export interface IHomeAssistantAdsConfig {
-  // TODO: replace with the TypeScript-native config for ads.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const adsDomain = "ads";
+export const adsDefaultName = "ADS";
+
+export type TAdsRawData = TSimpleLocalRawData;
+export interface IAdsSnapshot extends ISimpleLocalSnapshot {}
+export interface IAdsConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAdsConfig extends IAdsConfig {}
+
+export const adsProfile: ISimpleLocalIntegrationProfile = {
+  domain: "ads",
+  displayName: "ADS",
+  manufacturer: "Beckhoff",
+  model: "ADS PLC",
+  defaultName: "ADS",
+  defaultPort: 48898,
+  defaultProtocol: "tcp",
+  status: "control-runtime",
+  platforms: [
+    "sensor",
+    "switch",
+    "binary_sensor"
+  ],
+  serviceDomains: [
+    "switch"
+  ],
+  controlServices: [
+    "turn_on",
+    "turn_off",
+    "toggle"
+  ],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "ads",
+    "beckhoff",
+    "twincat",
+    "plc"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/ads",
+    upstreamDomain: "ads",
+    iotClass: "local_push",
+    qualityScale: "legacy",
+    requirements: [
+      "pyads==3.4.0"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "control-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh",
+        "turn_on",
+        "turn_off",
+        "toggle"
+      ],
+      platforms: [
+        "sensor",
+        "switch",
+        "binary_sensor"
+      ],
+      controls: true
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/ads/index.ts

@@ -1,2 +1,6 @@
+export * from './ads.classes.client.js';
+export * from './ads.classes.configflow.js';
 export * from './ads.classes.integration.js';
+export * from './ads.discovery.js';
+export * from './ads.mapper.js';
 export * from './ads.types.js';

ts/integrations/advantage_air/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/advantage_air/advantage_air.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAdvantageAirConfig } from './advantage_air.types.js';
+import { advantageAirProfile } from './advantage_air.types.js';
+
+export class AdvantageAirClient extends SimpleLocalClient<IAdvantageAirConfig> {
+  constructor(configArg: IAdvantageAirConfig) {
+    super(advantageAirProfile, configArg);
+  }
+}

ts/integrations/advantage_air/advantage_air.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAdvantageAirConfig } from './advantage_air.types.js';
+import { advantageAirProfile } from './advantage_air.types.js';
+
+export class AdvantageAirConfigFlow extends SimpleLocalConfigFlow<IAdvantageAirConfig> {
+  constructor() {
+    super(advantageAirProfile);
+  }
+}

ts/integrations/advantage_air/advantage_air.classes.integration.ts

@@ -1,26 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AdvantageAirConfigFlow } from './advantage_air.classes.configflow.js';
+import { createAdvantageAirDiscoveryDescriptor } from './advantage_air.discovery.js';
+import type { IAdvantageAirConfig } from './advantage_air.types.js';
+import { advantageAirDomain, advantageAirProfile } from './advantage_air.types.js';
+
+export class AdvantageAirIntegration extends SimpleLocalIntegration<IAdvantageAirConfig> {
+  public readonly domain = advantageAirDomain;
+  public readonly discoveryDescriptor = createAdvantageAirDiscoveryDescriptor();
+  public readonly configFlow = new AdvantageAirConfigFlow();
 
-export class HomeAssistantAdvantageAirIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "advantage_air",
-      displayName: "Advantage Air",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/advantage_air",
-  "upstreamDomain": "advantage_air",
-  "integrationType": "hub",
-  "iotClass": "local_polling",
-  "requirements": [
-    "advantage-air==0.4.4"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": [
-    "@Bre77"
-  ]
-},
-    });
+    super(advantageAirProfile);
   }
 }
+
+export class HomeAssistantAdvantageAirIntegration extends AdvantageAirIntegration {}

ts/integrations/advantage_air/advantage_air.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { advantageAirProfile } from './advantage_air.types.js';
+
+export const createAdvantageAirDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(advantageAirProfile);

ts/integrations/advantage_air/advantage_air.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAdvantageAirConfig } from './advantage_air.types.js';
+import { advantageAirProfile } from './advantage_air.types.js';
+
+export class AdvantageAirMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAdvantageAirConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: advantageAirProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAdvantageAirConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: advantageAirProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(advantageAirProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(advantageAirProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/advantage_air/advantage_air.types.ts

@@ -1,4 +1,92 @@
-export interface IHomeAssistantAdvantageAirConfig {
-  // TODO: replace with the TypeScript-native config for advantage_air.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const advantageAirDomain = "advantage_air";
+export const advantageAirDefaultName = "Advantage Air";
+
+export type TAdvantageAirRawData = TSimpleLocalRawData;
+export interface IAdvantageAirSnapshot extends ISimpleLocalSnapshot {}
+export interface IAdvantageAirConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAdvantageAirConfig extends IAdvantageAirConfig {}
+
+export const advantageAirProfile: ISimpleLocalIntegrationProfile = {
+  domain: "advantage_air",
+  displayName: "Advantage Air",
+  manufacturer: "Advantage Air",
+  model: "HVAC controller",
+  defaultName: "Advantage Air",
+  defaultProtocol: "local",
+  status: "control-runtime",
+  platforms: [
+    "climate",
+    "fan",
+    "sensor"
+  ],
+  serviceDomains: [
+    "climate",
+    "fan"
+  ],
+  controlServices: [
+    "set_temperature",
+    "set_hvac_mode",
+    "set_percentage",
+    "turn_on",
+    "turn_off"
+  ],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "advantage air",
+    "myair",
+    "myplace"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/advantage_air",
+    upstreamDomain: "advantage_air",
+    integrationType: "hub",
+    iotClass: "local_polling",
+    requirements: [
+      "advantage-air==0.4.4"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "control-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh",
+        "set_temperature",
+        "set_hvac_mode",
+        "set_percentage",
+        "turn_on",
+        "turn_off"
+      ],
+      platforms: [
+        "climate",
+        "fan",
+        "sensor"
+      ],
+      controls: true
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/advantage_air/index.ts

@@ -1,2 +1,6 @@
+export * from './advantage_air.classes.client.js';
+export * from './advantage_air.classes.configflow.js';
 export * from './advantage_air.classes.integration.js';
+export * from './advantage_air.discovery.js';
+export * from './advantage_air.mapper.js';
 export * from './advantage_air.types.js';

ts/integrations/airobot/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/airobot/airobot.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAirobotConfig } from './airobot.types.js';
+import { airobotProfile } from './airobot.types.js';
+
+export class AirobotClient extends SimpleLocalClient<IAirobotConfig> {
+  constructor(configArg: IAirobotConfig) {
+    super(airobotProfile, configArg);
+  }
+}

ts/integrations/airobot/airobot.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAirobotConfig } from './airobot.types.js';
+import { airobotProfile } from './airobot.types.js';
+
+export class AirobotConfigFlow extends SimpleLocalConfigFlow<IAirobotConfig> {
+  constructor() {
+    super(airobotProfile);
+  }
+}

ts/integrations/airobot/airobot.classes.integration.ts

@@ -1,27 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AirobotConfigFlow } from './airobot.classes.configflow.js';
+import { createAirobotDiscoveryDescriptor } from './airobot.discovery.js';
+import type { IAirobotConfig } from './airobot.types.js';
+import { airobotDomain, airobotProfile } from './airobot.types.js';
+
+export class AirobotIntegration extends SimpleLocalIntegration<IAirobotConfig> {
+  public readonly domain = airobotDomain;
+  public readonly discoveryDescriptor = createAirobotDiscoveryDescriptor();
+  public readonly configFlow = new AirobotConfigFlow();
 
-export class HomeAssistantAirobotIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "airobot",
-      displayName: "Airobot",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/airobot",
-  "upstreamDomain": "airobot",
-  "integrationType": "device",
-  "iotClass": "local_polling",
-  "qualityScale": "platinum",
-  "requirements": [
-    "pyairobotrest==0.3.0"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": [
-    "@mettolen"
-  ]
-},
-    });
+    super(airobotProfile);
   }
 }
+
+export class HomeAssistantAirobotIntegration extends AirobotIntegration {}

ts/integrations/airobot/airobot.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { airobotProfile } from './airobot.types.js';
+
+export const createAirobotDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(airobotProfile);

ts/integrations/airobot/airobot.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAirobotConfig } from './airobot.types.js';
+import { airobotProfile } from './airobot.types.js';
+
+export class AirobotMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAirobotConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: airobotProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAirobotConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: airobotProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(airobotProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(airobotProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/airobot/airobot.types.ts

@@ -1,4 +1,87 @@
-export interface IHomeAssistantAirobotConfig {
-  // TODO: replace with the TypeScript-native config for airobot.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const airobotDomain = "airobot";
+export const airobotDefaultName = "Airobot";
+
+export type TAirobotRawData = TSimpleLocalRawData;
+export interface IAirobotSnapshot extends ISimpleLocalSnapshot {}
+export interface IAirobotConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAirobotConfig extends IAirobotConfig {}
+
+export const airobotProfile: ISimpleLocalIntegrationProfile = {
+  domain: "airobot",
+  displayName: "Airobot",
+  manufacturer: "Airobot",
+  model: "Ventilation unit",
+  defaultName: "Airobot",
+  defaultProtocol: "local",
+  status: "control-runtime",
+  platforms: [
+    "fan",
+    "sensor",
+    "binary_sensor"
+  ],
+  serviceDomains: [
+    "fan"
+  ],
+  controlServices: [
+    "turn_on",
+    "turn_off",
+    "set_percentage"
+  ],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "airobot",
+    "ventilation"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/airobot",
+    upstreamDomain: "airobot",
+    integrationType: "device",
+    iotClass: "local_polling",
+    qualityScale: "platinum",
+    requirements: [
+      "pyairobotrest==0.3.0"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "control-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh",
+        "turn_on",
+        "turn_off",
+        "set_percentage"
+      ],
+      platforms: [
+        "fan",
+        "sensor",
+        "binary_sensor"
+      ],
+      controls: true
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/airobot/index.ts

@@ -1,2 +1,6 @@
+export * from './airobot.classes.client.js';
+export * from './airobot.classes.configflow.js';
 export * from './airobot.classes.integration.js';
+export * from './airobot.discovery.js';
+export * from './airobot.mapper.js';
 export * from './airobot.types.js';

ts/integrations/airq/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/airq/airq.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAirqConfig } from './airq.types.js';
+import { airqProfile } from './airq.types.js';
+
+export class AirqClient extends SimpleLocalClient<IAirqConfig> {
+  constructor(configArg: IAirqConfig) {
+    super(airqProfile, configArg);
+  }
+}

ts/integrations/airq/airq.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAirqConfig } from './airq.types.js';
+import { airqProfile } from './airq.types.js';
+
+export class AirqConfigFlow extends SimpleLocalConfigFlow<IAirqConfig> {
+  constructor() {
+    super(airqProfile);
+  }
+}

ts/integrations/airq/airq.classes.integration.ts

@@ -1,27 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AirqConfigFlow } from './airq.classes.configflow.js';
+import { createAirqDiscoveryDescriptor } from './airq.discovery.js';
+import type { IAirqConfig } from './airq.types.js';
+import { airqDomain, airqProfile } from './airq.types.js';
+
+export class AirqIntegration extends SimpleLocalIntegration<IAirqConfig> {
+  public readonly domain = airqDomain;
+  public readonly discoveryDescriptor = createAirqDiscoveryDescriptor();
+  public readonly configFlow = new AirqConfigFlow();
 
-export class HomeAssistantAirqIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "airq",
-      displayName: "air-Q",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/airq",
-  "upstreamDomain": "airq",
-  "integrationType": "hub",
-  "iotClass": "local_polling",
-  "requirements": [
-    "aioairq==0.4.7"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": [
-    "@Sibgatulin",
-    "@dl2080"
-  ]
-},
-    });
+    super(airqProfile);
   }
 }
+
+export class HomeAssistantAirqIntegration extends AirqIntegration {}

ts/integrations/airq/airq.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { airqProfile } from './airq.types.js';
+
+export const createAirqDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(airqProfile);

ts/integrations/airq/airq.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAirqConfig } from './airq.types.js';
+import { airqProfile } from './airq.types.js';
+
+export class AirqMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAirqConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: airqProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAirqConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: airqProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(airqProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(airqProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/airq/airq.types.ts

@@ -1,4 +1,76 @@
-export interface IHomeAssistantAirqConfig {
-  // TODO: replace with the TypeScript-native config for airq.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const airqDomain = "airq";
+export const airqDefaultName = "air-Q";
+
+export type TAirqRawData = TSimpleLocalRawData;
+export interface IAirqSnapshot extends ISimpleLocalSnapshot {}
+export interface IAirqConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAirqConfig extends IAirqConfig {}
+
+export const airqProfile: ISimpleLocalIntegrationProfile = {
+  domain: "airq",
+  displayName: "air-Q",
+  manufacturer: "air-Q",
+  model: "Air quality monitor",
+  defaultName: "air-Q",
+  defaultProtocol: "local",
+  status: "read-only-runtime",
+  platforms: [
+    "sensor",
+    "binary_sensor"
+  ],
+  serviceDomains: [],
+  controlServices: [],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "air-q",
+    "airq",
+    "air quality"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/airq",
+    upstreamDomain: "airq",
+    integrationType: "hub",
+    iotClass: "local_polling",
+    requirements: [
+      "aioairq==0.4.7"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "read-only-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh"
+      ],
+      platforms: [
+        "sensor",
+        "binary_sensor"
+      ],
+      controls: false
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/airq/index.ts

@@ -1,2 +1,6 @@
+export * from './airq.classes.client.js';
+export * from './airq.classes.configflow.js';
 export * from './airq.classes.integration.js';
+export * from './airq.discovery.js';
+export * from './airq.mapper.js';
 export * from './airq.types.js';

ts/integrations/airthings_ble/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/airthings_ble/airthings_ble.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAirthingsBleConfig } from './airthings_ble.types.js';
+import { airthingsBleProfile } from './airthings_ble.types.js';
+
+export class AirthingsBleClient extends SimpleLocalClient<IAirthingsBleConfig> {
+  constructor(configArg: IAirthingsBleConfig) {
+    super(airthingsBleProfile, configArg);
+  }
+}

ts/integrations/airthings_ble/airthings_ble.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAirthingsBleConfig } from './airthings_ble.types.js';
+import { airthingsBleProfile } from './airthings_ble.types.js';
+
+export class AirthingsBleConfigFlow extends SimpleLocalConfigFlow<IAirthingsBleConfig> {
+  constructor() {
+    super(airthingsBleProfile);
+  }
+}

ts/integrations/airthings_ble/airthings_ble.classes.integration.ts

@@ -1,29 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { AirthingsBleConfigFlow } from './airthings_ble.classes.configflow.js';
+import { createAirthingsBleDiscoveryDescriptor } from './airthings_ble.discovery.js';
+import type { IAirthingsBleConfig } from './airthings_ble.types.js';
+import { airthingsBleDomain, airthingsBleProfile } from './airthings_ble.types.js';
+
+export class AirthingsBleIntegration extends SimpleLocalIntegration<IAirthingsBleConfig> {
+  public readonly domain = airthingsBleDomain;
+  public readonly discoveryDescriptor = createAirthingsBleDiscoveryDescriptor();
+  public readonly configFlow = new AirthingsBleConfigFlow();
 
-export class HomeAssistantAirthingsBleIntegration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "airthings_ble",
-      displayName: "Airthings BLE",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/airthings_ble",
-  "upstreamDomain": "airthings_ble",
-  "integrationType": "device",
-  "iotClass": "local_polling",
-  "requirements": [
-    "airthings-ble==1.2.0"
-  ],
-  "dependencies": [
-    "bluetooth_adapters"
-  ],
-  "afterDependencies": [],
-  "codeowners": [
-    "@vincegio",
-    "@LaStrada"
-  ]
-},
-    });
+    super(airthingsBleProfile);
   }
 }
+
+export class HomeAssistantAirthingsBleIntegration extends AirthingsBleIntegration {}

ts/integrations/airthings_ble/airthings_ble.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { airthingsBleProfile } from './airthings_ble.types.js';
+
+export const createAirthingsBleDiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(airthingsBleProfile);

ts/integrations/airthings_ble/airthings_ble.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAirthingsBleConfig } from './airthings_ble.types.js';
+import { airthingsBleProfile } from './airthings_ble.types.js';
+
+export class AirthingsBleMapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAirthingsBleConfig>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: airthingsBleProfile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAirthingsBleConfig, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: airthingsBleProfile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(airthingsBleProfile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(airthingsBleProfile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/airthings_ble/airthings_ble.types.ts

@@ -1,4 +1,78 @@
-export interface IHomeAssistantAirthingsBleConfig {
-  // TODO: replace with the TypeScript-native config for airthings_ble.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const airthingsBleDomain = "airthings_ble";
+export const airthingsBleDefaultName = "Airthings BLE";
+
+export type TAirthingsBleRawData = TSimpleLocalRawData;
+export interface IAirthingsBleSnapshot extends ISimpleLocalSnapshot {}
+export interface IAirthingsBleConfig extends ISimpleLocalConfig {}
+export interface IHomeAssistantAirthingsBleConfig extends IAirthingsBleConfig {}
+
+export const airthingsBleProfile: ISimpleLocalIntegrationProfile = {
+  domain: "airthings_ble",
+  displayName: "Airthings BLE",
+  manufacturer: "Airthings",
+  model: "BLE sensor",
+  defaultName: "Airthings BLE",
+  defaultProtocol: "local",
+  status: "read-only-runtime",
+  platforms: [
+    "sensor",
+    "binary_sensor"
+  ],
+  serviceDomains: [],
+  controlServices: [],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "airthings",
+    "wave",
+    "bluetooth"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/airthings_ble",
+    upstreamDomain: "airthings_ble",
+    integrationType: "device",
+    iotClass: "local_polling",
+    requirements: [
+      "airthings-ble==1.2.0"
+    ],
+    dependencies: [
+      "bluetooth_adapters"
+    ],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "read-only-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh"
+      ],
+      platforms: [
+        "sensor",
+        "binary_sensor"
+      ],
+      controls: false
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/airthings_ble/index.ts

@@ -1,2 +1,6 @@
+export * from './airthings_ble.classes.client.js';
+export * from './airthings_ble.classes.configflow.js';
 export * from './airthings_ble.classes.integration.js';
+export * from './airthings_ble.discovery.js';
+export * from './airthings_ble.mapper.js';
 export * from './airthings_ble.types.js';

ts/integrations/airtouch4/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/airtouch4/airtouch4.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAirtouch4Config } from './airtouch4.types.js';
+import { airtouch4Profile } from './airtouch4.types.js';
+
+export class Airtouch4Client extends SimpleLocalClient<IAirtouch4Config> {
+  constructor(configArg: IAirtouch4Config) {
+    super(airtouch4Profile, configArg);
+  }
+}

ts/integrations/airtouch4/airtouch4.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAirtouch4Config } from './airtouch4.types.js';
+import { airtouch4Profile } from './airtouch4.types.js';
+
+export class Airtouch4ConfigFlow extends SimpleLocalConfigFlow<IAirtouch4Config> {
+  constructor() {
+    super(airtouch4Profile);
+  }
+}

ts/integrations/airtouch4/airtouch4.classes.integration.ts

@@ -1,26 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { Airtouch4ConfigFlow } from './airtouch4.classes.configflow.js';
+import { createAirtouch4DiscoveryDescriptor } from './airtouch4.discovery.js';
+import type { IAirtouch4Config } from './airtouch4.types.js';
+import { airtouch4Domain, airtouch4Profile } from './airtouch4.types.js';
+
+export class Airtouch4Integration extends SimpleLocalIntegration<IAirtouch4Config> {
+  public readonly domain = airtouch4Domain;
+  public readonly discoveryDescriptor = createAirtouch4DiscoveryDescriptor();
+  public readonly configFlow = new Airtouch4ConfigFlow();
 
-export class HomeAssistantAirtouch4Integration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "airtouch4",
-      displayName: "AirTouch 4",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/airtouch4",
-  "upstreamDomain": "airtouch4",
-  "integrationType": "device",
-  "iotClass": "local_polling",
-  "requirements": [
-    "airtouch4pyapi==1.0.5"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": [
-    "@samsinnamon"
-  ]
-},
-    });
+    super(airtouch4Profile);
   }
 }
+
+export class HomeAssistantAirtouch4Integration extends Airtouch4Integration {}

ts/integrations/airtouch4/airtouch4.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { airtouch4Profile } from './airtouch4.types.js';
+
+export const createAirtouch4DiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(airtouch4Profile);

ts/integrations/airtouch4/airtouch4.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAirtouch4Config } from './airtouch4.types.js';
+import { airtouch4Profile } from './airtouch4.types.js';
+
+export class Airtouch4Mapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAirtouch4Config>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: airtouch4Profile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAirtouch4Config, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: airtouch4Profile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(airtouch4Profile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(airtouch4Profile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/airtouch4/airtouch4.types.ts

@@ -1,4 +1,92 @@
-export interface IHomeAssistantAirtouch4Config {
-  // TODO: replace with the TypeScript-native config for airtouch4.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const airtouch4Domain = "airtouch4";
+export const airtouch4DefaultName = "AirTouch 4";
+
+export type TAirtouch4RawData = TSimpleLocalRawData;
+export interface IAirtouch4Snapshot extends ISimpleLocalSnapshot {}
+export interface IAirtouch4Config extends ISimpleLocalConfig {}
+export interface IHomeAssistantAirtouch4Config extends IAirtouch4Config {}
+
+export const airtouch4Profile: ISimpleLocalIntegrationProfile = {
+  domain: "airtouch4",
+  displayName: "AirTouch 4",
+  manufacturer: "AirTouch",
+  model: "AirTouch 4",
+  defaultName: "AirTouch 4",
+  defaultProtocol: "local",
+  status: "control-runtime",
+  platforms: [
+    "climate",
+    "fan",
+    "sensor"
+  ],
+  serviceDomains: [
+    "climate",
+    "fan"
+  ],
+  controlServices: [
+    "set_temperature",
+    "set_hvac_mode",
+    "set_percentage",
+    "turn_on",
+    "turn_off"
+  ],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "airtouch",
+    "airtouch4",
+    "hvac"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/airtouch4",
+    upstreamDomain: "airtouch4",
+    integrationType: "device",
+    iotClass: "local_polling",
+    requirements: [
+      "airtouch4pyapi==1.0.5"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "control-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh",
+        "set_temperature",
+        "set_hvac_mode",
+        "set_percentage",
+        "turn_on",
+        "turn_off"
+      ],
+      platforms: [
+        "climate",
+        "fan",
+        "sensor"
+      ],
+      controls: true
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/airtouch4/index.ts

@@ -1,2 +1,6 @@
+export * from './airtouch4.classes.client.js';
+export * from './airtouch4.classes.configflow.js';
 export * from './airtouch4.classes.integration.js';
+export * from './airtouch4.discovery.js';
+export * from './airtouch4.mapper.js';
 export * from './airtouch4.types.js';

ts/integrations/airtouch5/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/airtouch5/airtouch5.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAirtouch5Config } from './airtouch5.types.js';
+import { airtouch5Profile } from './airtouch5.types.js';
+
+export class Airtouch5Client extends SimpleLocalClient<IAirtouch5Config> {
+  constructor(configArg: IAirtouch5Config) {
+    super(airtouch5Profile, configArg);
+  }
+}

ts/integrations/airtouch5/airtouch5.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAirtouch5Config } from './airtouch5.types.js';
+import { airtouch5Profile } from './airtouch5.types.js';
+
+export class Airtouch5ConfigFlow extends SimpleLocalConfigFlow<IAirtouch5Config> {
+  constructor() {
+    super(airtouch5Profile);
+  }
+}

ts/integrations/airtouch5/airtouch5.classes.integration.ts

@@ -1,26 +1,17 @@
-import { DescriptorOnlyIntegration } from '../../core/classes.descriptoronlyintegration.js';
+import { SimpleLocalIntegration } from '../../core/index.js';
+import { Airtouch5ConfigFlow } from './airtouch5.classes.configflow.js';
+import { createAirtouch5DiscoveryDescriptor } from './airtouch5.discovery.js';
+import type { IAirtouch5Config } from './airtouch5.types.js';
+import { airtouch5Domain, airtouch5Profile } from './airtouch5.types.js';
+
+export class Airtouch5Integration extends SimpleLocalIntegration<IAirtouch5Config> {
+  public readonly domain = airtouch5Domain;
+  public readonly discoveryDescriptor = createAirtouch5DiscoveryDescriptor();
+  public readonly configFlow = new Airtouch5ConfigFlow();
 
-export class HomeAssistantAirtouch5Integration extends DescriptorOnlyIntegration {
   constructor() {
-    super({
-      domain: "airtouch5",
-      displayName: "AirTouch 5",
-      status: 'descriptor-only',
-      metadata: {
-  "source": "home-assistant/core",
-  "upstreamPath": "homeassistant/components/airtouch5",
-  "upstreamDomain": "airtouch5",
-  "integrationType": "hub",
-  "iotClass": "local_push",
-  "requirements": [
-    "airtouch5py==0.4.0"
-  ],
-  "dependencies": [],
-  "afterDependencies": [],
-  "codeowners": [
-    "@danzel"
-  ]
-},
-    });
+    super(airtouch5Profile);
   }
 }
+
+export class HomeAssistantAirtouch5Integration extends Airtouch5Integration {}

ts/integrations/airtouch5/airtouch5.discovery.ts

@@ -0,0 +1,4 @@
+import { createSimpleLocalDiscoveryDescriptor } from '../../core/index.js';
+import { airtouch5Profile } from './airtouch5.types.js';
+
+export const createAirtouch5DiscoveryDescriptor = () => createSimpleLocalDiscoveryDescriptor(airtouch5Profile);

ts/integrations/airtouch5/airtouch5.mapper.ts

@@ -0,0 +1,26 @@
+import type * as shxInterfaces from '@smarthome.exchange/interfaces';
+import { SimpleLocalMapper, type IIntegrationEntity, type ISimpleLocalSnapshot, type ISimpleLocalSnapshotOptions, type TSimpleLocalRawData } from '../../core/index.js';
+import type { IAirtouch5Config } from './airtouch5.types.js';
+import { airtouch5Profile } from './airtouch5.types.js';
+
+export class Airtouch5Mapper {
+  public static toSnapshot(optionsArg: Omit<ISimpleLocalSnapshotOptions<IAirtouch5Config>, 'profile'>): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ ...optionsArg, profile: airtouch5Profile });
+  }
+
+  public static toSnapshotFromRaw(configArg: IAirtouch5Config, rawDataArg: TSimpleLocalRawData): ISimpleLocalSnapshot {
+    return SimpleLocalMapper.toSnapshot({ profile: airtouch5Profile, config: configArg, rawData: rawDataArg, online: true, source: 'manual' });
+  }
+
+  public static toDevices(snapshotArg: ISimpleLocalSnapshot): shxInterfaces.data.IDeviceDefinition[] {
+    return SimpleLocalMapper.toDevices(airtouch5Profile, snapshotArg);
+  }
+
+  public static toEntities(snapshotArg: ISimpleLocalSnapshot): IIntegrationEntity[] {
+    return SimpleLocalMapper.toEntities(airtouch5Profile, snapshotArg);
+  }
+
+  public static slug(valueArg: unknown): string {
+    return SimpleLocalMapper.slug(valueArg);
+  }
+}

ts/integrations/airtouch5/airtouch5.types.ts

@@ -1,4 +1,92 @@
-export interface IHomeAssistantAirtouch5Config {
-  // TODO: replace with the TypeScript-native config for airtouch5.
-  [key: string]: unknown;
-}
+import type { ISimpleLocalConfig, ISimpleLocalIntegrationProfile, ISimpleLocalSnapshot, TSimpleLocalRawData } from '../../core/index.js';
+
+export const airtouch5Domain = "airtouch5";
+export const airtouch5DefaultName = "AirTouch 5";
+
+export type TAirtouch5RawData = TSimpleLocalRawData;
+export interface IAirtouch5Snapshot extends ISimpleLocalSnapshot {}
+export interface IAirtouch5Config extends ISimpleLocalConfig {}
+export interface IHomeAssistantAirtouch5Config extends IAirtouch5Config {}
+
+export const airtouch5Profile: ISimpleLocalIntegrationProfile = {
+  domain: "airtouch5",
+  displayName: "AirTouch 5",
+  manufacturer: "AirTouch",
+  model: "AirTouch 5",
+  defaultName: "AirTouch 5",
+  defaultProtocol: "local",
+  status: "control-runtime",
+  platforms: [
+    "climate",
+    "fan",
+    "sensor"
+  ],
+  serviceDomains: [
+    "climate",
+    "fan"
+  ],
+  controlServices: [
+    "set_temperature",
+    "set_hvac_mode",
+    "set_percentage",
+    "turn_on",
+    "turn_off"
+  ],
+  discoverySources: [
+    "manual",
+    "mdns",
+    "ssdp",
+    "http",
+    "custom"
+  ],
+  discoveryKeywords: [
+    "airtouch",
+    "airtouch5",
+    "hvac"
+  ],
+  metadata: {
+    source: "home-assistant/core",
+    upstreamPath: "homeassistant/components/airtouch5",
+    upstreamDomain: "airtouch5",
+    integrationType: "hub",
+    iotClass: "local_push",
+    requirements: [
+      "airtouch5py==0.4.0"
+    ],
+    dependencies: [],
+    afterDependencies: [],
+    codeowners: [],
+    configFlow: true,
+    runtime: {
+      type: "control-runtime",
+      services: [
+        "snapshot",
+        "status",
+        "refresh",
+        "set_temperature",
+        "set_hvac_mode",
+        "set_percentage",
+        "turn_on",
+        "turn_off"
+      ],
+      platforms: [
+        "climate",
+        "fan",
+        "sensor"
+      ],
+      controls: true
+    },
+    localApi: {
+      implemented: [
+        "manual local endpoint setup",
+        "snapshot, raw data, snapshotProvider, and injected native client operation",
+        "generic HTTP/TCP local transport when config.path, config.transport, or documented defaults are supplied"
+      ],
+      explicitUnsupported: [
+        "claiming live command success without injected client.execute or commandExecutor",
+        "cloud account flows and remote API polling",
+        "device-specific protocol features not represented by snapshot/rawData/client/executor inputs"
+      ]
+    }
+  }
+};

ts/integrations/airtouch5/index.ts

@@ -1,2 +1,6 @@
+export * from './airtouch5.classes.client.js';
+export * from './airtouch5.classes.configflow.js';
 export * from './airtouch5.classes.integration.js';
+export * from './airtouch5.discovery.js';
+export * from './airtouch5.mapper.js';
 export * from './airtouch5.types.js';

ts/integrations/airvisual_pro/.generated-by-smarthome-exchange

@@ -1 +0,0 @@
-This folder is generated from Home Assistant component metadata. Replace it with a handwritten TypeScript port when implementing runtime support.

ts/integrations/airvisual_pro/airvisual_pro.classes.client.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalClient } from '../../core/index.js';
+import type { IAirvisualProConfig } from './airvisual_pro.types.js';
+import { airvisualProProfile } from './airvisual_pro.types.js';
+
+export class AirvisualProClient extends SimpleLocalClient<IAirvisualProConfig> {
+  constructor(configArg: IAirvisualProConfig) {
+    super(airvisualProProfile, configArg);
+  }
+}

ts/integrations/airvisual_pro/airvisual_pro.classes.configflow.ts

@@ -0,0 +1,9 @@
+import { SimpleLocalConfigFlow } from '../../core/index.js';
+import type { IAirvisualProConfig } from './airvisual_pro.types.js';
+import { airvisualProProfile } from './airvisual_pro.types.js';
+
+export class AirvisualProConfigFlow extends SimpleLocalConfigFlow<IAirvisualProConfig> {
+  constructor() {
+    super(airvisualProProfile);
+  }
+}