@hashsome/integration.home-assistant 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,183 @@
+import { callService as haCallService, createConnection, createLongLivedTokenAuth, subscribeEntities, } from 'home-assistant-js-websocket';
+import { assetUrl, BaseIntegration, UnknownEntityError, } from '@hashsome/core';
+import { decodeItemId, toBrowseItem } from './browse.js';
+import { DEFAULT_BUCKET, PERIODS, RANGE_MS, } from './history.js';
+import { toServiceRequest } from './commands.js';
+import { mapEntity } from './mappers/index.js';
+export async function createHaClient(options) {
+    const auth = createLongLivedTokenAuth(options.url, options.token);
+    const connection = await createConnection({ auth });
+    return {
+        subscribeEntities: (listener) => subscribeEntities(connection, listener),
+        callService: (domain, service, data, target) => haCallService(connection, domain, service, data, target),
+        sendCommand: (message) => connection.sendMessagePromise(message),
+        on: (event, listener) => connection.addEventListener(event, listener),
+        close: () => connection.close(),
+    };
+}
+export class HomeAssistantIntegration extends BaseIntegration {
+    id;
+    #options;
+    #client;
+    #stopEntities;
+    #cache = new Map();
+    constructor(options) {
+        super();
+        this.id = options.id ?? 'ha';
+        this.#options = options;
+    }
+    async connect() {
+        if (this.#client) {
+            return;
+        }
+        this.setStatus('connecting');
+        try {
+            const client = await (this.#options.createClient ?? (() => createHaClient(this.#options)))();
+            this.#client = client;
+            client.on('ready', () => this.setStatus('connected'));
+            client.on('disconnected', () => this.setStatus('disconnected'));
+            client.on('reconnect-error', () => this.setStatus('error'));
+            // `connect()` resolves only once the first full set of entities has arrived, so
+            // `listEntities()` is complete — and "unknown entity" can be decided — from then on.
+            const firstLoad = new Promise((resolve) => {
+                this.#stopEntities = client.subscribeEntities((entities) => {
+                    this.#applyEntities(entities);
+                    resolve();
+                });
+            });
+            await firstLoad;
+            this.setStatus('connected');
+        }
+        catch (error) {
+            this.setStatus('error');
+            throw error;
+        }
+    }
+    disconnect() {
+        this.#stopEntities?.();
+        this.#stopEntities = undefined;
+        this.#client?.close();
+        this.#client = undefined;
+        this.setStatus('disconnected');
+    }
+    async command(entityId, name, args) {
+        const client = this.#requireClient();
+        const entity = this.getEntity(entityId);
+        if (!entity) {
+            throw new UnknownEntityError(this.id, entityId);
+        }
+        const { domain, service, data } = toServiceRequest(entityId, entity, name, args);
+        await client.callService(domain, service, data, { entity_id: [entityId] });
+    }
+    #assetUrl = (path) => assetUrl(this.id, path);
+    /**
+     * A sensor's past values from Home Assistant's long-term statistics: the average per bucket for a
+     * measurement (temperature, power), or how much the counter grew per bucket for a running total
+     * (energy). An entity that has no statistics (not a sensor with a `state_class`) has no points.
+     */
+    async history(entityId, query) {
+        const client = this.#requireClient();
+        if (!this.getEntity(entityId)) {
+            throw new UnknownEntityError(this.id, entityId);
+        }
+        const [meta] = await client.sendCommand({
+            type: 'recorder/get_statistics_metadata',
+            statistic_ids: [entityId],
+        });
+        if (!meta || (!meta.has_sum && !meta.has_mean)) {
+            return { points: [], kind: 'measurement' };
+        }
+        const total = meta.has_sum;
+        const field = total ? 'change' : 'mean';
+        const bucket = query.bucket ?? DEFAULT_BUCKET[query.range];
+        const found = await client.sendCommand({
+            type: 'recorder/statistics_during_period',
+            start_time: new Date(Date.now() - RANGE_MS[query.range]).toISOString(),
+            statistic_ids: [entityId],
+            period: PERIODS[bucket],
+            types: [field],
+        });
+        const points = (found[entityId] ?? []).flatMap((row) => {
+            const value = row[field];
+            return typeof value === 'number'
+                ? [{ timestamp: new Date(row.start).toISOString(), value }]
+                : [];
+        });
+        const unit = meta.statistics_unit_of_measurement;
+        return { points, kind: total ? 'total' : 'measurement', ...(unit ? { unit } : {}) };
+    }
+    /** A file Home Assistant serves (artwork, a person's picture), fetched with the token. Only a
+     * path on Home Assistant itself is accepted, never another address. */
+    async fetchAsset(path) {
+        const base = new URL(this.#options.url);
+        const target = new URL(path, base);
+        if (!path.startsWith('/') || path.startsWith('//') || target.origin !== base.origin) {
+            throw new Error('Not a path on Home Assistant');
+        }
+        return fetch(target, { headers: { Authorization: `Bearer ${this.#options.token}` } });
+    }
+    /** One level of the player's own media library, from `media_player/browse_media`. */
+    async browse(entityId, query) {
+        const client = this.#requireClient();
+        const entity = this.getEntity(entityId);
+        if (entity?.kind !== 'mediaPlayer') {
+            throw new UnknownEntityError(this.id, entityId);
+        }
+        if (query.search !== undefined) {
+            throw new Error('This library cannot be searched');
+        }
+        const at = query.path === undefined ? undefined : decodeItemId(query.path);
+        const level = await client.sendCommand({
+            type: 'media_player/browse_media',
+            entity_id: entityId,
+            ...(at ? { media_content_type: at.contentType, media_content_id: at.contentId } : {}),
+        });
+        return {
+            ...(at && level.title ? { title: level.title } : {}),
+            items: (level.children ?? []).map((media) => toBrowseItem(media, this.#assetUrl)),
+        };
+    }
+    /** Calls any Home Assistant service: `{ domain, service, entityIds?, data? }`. */
+    async callRaw(request) {
+        const { domain, service, entityIds, data } = request;
+        if (typeof domain !== 'string' || typeof service !== 'string') {
+            throw new Error('A raw Home Assistant request needs a "domain" and a "service"');
+        }
+        const ids = Array.isArray(entityIds) ? entityIds.filter((i) => typeof i === 'string') : [];
+        return this.#requireClient().callService(domain, service, data && typeof data === 'object' ? data : undefined, ids.length > 0 ? { entity_id: ids } : undefined);
+    }
+    async getAreas() {
+        return this.#requireClient().sendCommand({ type: 'config/area_registry/list' });
+    }
+    async getEntityRegistry() {
+        return this.#requireClient().sendCommand({
+            type: 'config/entity_registry/list',
+        });
+    }
+    #requireClient() {
+        if (!this.#client) {
+            throw new Error('Home Assistant integration is not connected');
+        }
+        return this.#client;
+    }
+    #applyEntities(entities) {
+        const next = new Map();
+        const nextCache = new Map();
+        const options = {
+            temperatureUnit: this.#options.temperatureUnit ?? '°C',
+            assetUrl: this.#assetUrl,
+        };
+        for (const [id, entity] of Object.entries(entities)) {
+            // The HA lib keeps object identity for unchanged entities; reuse our mapped input so
+            // replaceEntities only notifies subscribers of real changes.
+            const cached = this.#cache.get(id);
+            const entry = cached && cached.source === entity
+                ? cached
+                : { source: entity, input: mapEntity(entity, options) };
+            nextCache.set(id, entry);
+            next.set(id, entry.input);
+        }
+        this.#cache = nextCache;
+        this.replaceEntities(next);
+    }
+}

package/dist/mappers/climate.d.ts

@@ -0,0 +1,6 @@
+import type { ClimateMode, EntityInput } from '@hashsome/core';
+import type { HassEntity } from 'home-assistant-js-websocket';
+/** Home Assistant's HVAC mode names and the model's (camelCase) ones. */
+export declare const HVAC_TO_MODE: Record<string, ClimateMode>;
+export declare const MODE_TO_HVAC: Record<ClimateMode, string>;
+export declare function mapClimate(entity: HassEntity, unit: '°C' | '°F'): EntityInput;

package/dist/mappers/climate.js

@@ -0,0 +1,55 @@
+import { baseOf, num, str, strings } from './common.js';
+/** Home Assistant's HVAC mode names and the model's (camelCase) ones. */
+export const HVAC_TO_MODE = {
+    off: 'off',
+    heat: 'heat',
+    cool: 'cool',
+    auto: 'auto',
+    heat_cool: 'heatCool',
+    dry: 'dry',
+    fan_only: 'fanOnly',
+};
+export const MODE_TO_HVAC = {
+    off: 'off',
+    heat: 'heat',
+    cool: 'cool',
+    auto: 'auto',
+    heatCool: 'heat_cool',
+    dry: 'dry',
+    fanOnly: 'fan_only',
+};
+const ACTION = {
+    off: 'off',
+    idle: 'idle',
+    heating: 'heating',
+    cooling: 'cooling',
+    drying: 'drying',
+    fan: 'fan',
+};
+export function mapClimate(entity, unit) {
+    const a = entity.attributes;
+    const modes = strings(a.hvac_modes).flatMap((m) => (HVAC_TO_MODE[m] ? [HVAC_TO_MODE[m]] : []));
+    const target = num(a.temperature);
+    const current = num(a.current_temperature);
+    const humidity = num(a.current_humidity);
+    const action = ACTION[str(a.hvac_action) ?? ''];
+    const preset = str(a.preset_mode);
+    return {
+        kind: 'climate',
+        ...baseOf(entity),
+        mode: HVAC_TO_MODE[entity.state] ?? 'off',
+        ...(action ? { action } : {}),
+        ...(target !== undefined ? { targetTemperature: target } : {}),
+        ...(current !== undefined ? { currentTemperature: current } : {}),
+        ...(humidity !== undefined ? { humidity } : {}),
+        unit,
+        ...(preset ? { preset } : {}),
+        capabilities: {
+            modes: modes.length > 0 ? modes : ['off', 'heat'],
+            presets: strings(a.preset_modes),
+            targetTemperature: target !== undefined,
+            step: num(a.target_temp_step) ?? 0.5,
+            range: { min: num(a.min_temp) ?? 5, max: num(a.max_temp) ?? 35 },
+        },
+    };
+}

package/dist/mappers/common.d.ts

@@ -0,0 +1,21 @@
+import type { Availability } from '@hashsome/core';
+import type { HassEntity } from 'home-assistant-js-websocket';
+/** The domain of a Home Assistant entity id: `light` for `light.kitchen`. */
+export declare function domainOf(entityId: string): string;
+export declare function availabilityOf(entity: HassEntity): Availability;
+/** A file address in an entity attribute. Home Assistant serves its own files from a path like
+ * `/api/media_player_proxy/…` that only makes sense on Home Assistant, so those go through
+ * `toAssetUrl`; a full address is kept as it is. */
+export declare function fileUrl(value: string, toAssetUrl: (path: string) => string): string;
+export declare function nameOf(entity: HassEntity): string;
+/** What every mapped entity shares: name, availability, timestamps and the untouched payload. */
+export declare function baseOf(entity: HassEntity): {
+    name: string;
+    availability: Availability;
+    lastChanged?: string;
+    lastUpdated?: string;
+    raw: Record<string, unknown>;
+};
+export declare const num: (value: unknown) => number | undefined;
+export declare const str: (value: unknown) => string | undefined;
+export declare const strings: (value: unknown) => string[];

package/dist/mappers/common.js

@@ -0,0 +1,37 @@
+/** The domain of a Home Assistant entity id: `light` for `light.kitchen`. */
+export function domainOf(entityId) {
+    const index = entityId.indexOf('.');
+    return index === -1 ? entityId : entityId.slice(0, index);
+}
+export function availabilityOf(entity) {
+    if (entity.state === 'unavailable') {
+        return 'unavailable';
+    }
+    if (entity.state === 'unknown') {
+        return 'unknown';
+    }
+    return 'ready';
+}
+/** A file address in an entity attribute. Home Assistant serves its own files from a path like
+ * `/api/media_player_proxy/…` that only makes sense on Home Assistant, so those go through
+ * `toAssetUrl`; a full address is kept as it is. */
+export function fileUrl(value, toAssetUrl) {
+    return value.startsWith('/') && !value.startsWith('//') ? toAssetUrl(value) : value;
+}
+export function nameOf(entity) {
+    const name = entity.attributes.friendly_name;
+    return typeof name === 'string' && name ? name : entity.entity_id;
+}
+/** What every mapped entity shares: name, availability, timestamps and the untouched payload. */
+export function baseOf(entity) {
+    return {
+        name: nameOf(entity),
+        availability: availabilityOf(entity),
+        ...(entity.last_changed ? { lastChanged: entity.last_changed } : {}),
+        ...(entity.last_updated ? { lastUpdated: entity.last_updated } : {}),
+        raw: { state: entity.state, attributes: entity.attributes },
+    };
+}
+export const num = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+export const str = (value) => typeof value === 'string' && value ? value : undefined;
+export const strings = (value) => Array.isArray(value) ? value.filter((v) => typeof v === 'string') : [];

package/dist/mappers/index.d.ts

@@ -0,0 +1,14 @@
+import type { EntityInput } from '@hashsome/core';
+import type { HassEntity } from 'home-assistant-js-websocket';
+export interface MapOptions {
+    /** Home Assistant reports the temperature unit in its own config, not per entity. */
+    temperatureUnit: '°C' | '°F';
+    /** Turns a path on Home Assistant into an address the browser can load. Defaults to leaving it. */
+    assetUrl?: (path: string) => string;
+}
+/** Domains that are something to trigger, not something with a state to read. */
+export declare const ACTION_DOMAINS: string[];
+/** Domains with two states that can be flipped (a lock is "on" while locked). */
+export declare const SWITCH_DOMAINS: string[];
+/** Maps a Home Assistant entity to the generic model (everything but `ref`). Pure. */
+export declare function mapEntity(entity: HassEntity, options: MapOptions): EntityInput;

package/dist/mappers/index.js

@@ -0,0 +1,37 @@
+import { domainOf } from './common.js';
+import { mapClimate } from './climate.js';
+import { mapLight } from './light.js';
+import { mapMediaPlayer } from './media-player.js';
+import { mapWeather } from './weather.js';
+import { mapAction, mapGeneric, mapPerson, mapSensor, mapSwitch } from './simple.js';
+/** Domains that are something to trigger, not something with a state to read. */
+export const ACTION_DOMAINS = ['scene', 'script', 'button', 'input_button', 'automation', 'vacuum'];
+/** Domains with two states that can be flipped (a lock is "on" while locked). */
+export const SWITCH_DOMAINS = ['switch', 'fan', 'input_boolean', 'lock'];
+/** Maps a Home Assistant entity to the generic model (everything but `ref`). Pure. */
+export function mapEntity(entity, options) {
+    const domain = domainOf(entity.entity_id);
+    switch (domain) {
+        case 'media_player':
+            return mapMediaPlayer(entity, options.assetUrl);
+        case 'light':
+            return mapLight(entity);
+        case 'climate':
+            return mapClimate(entity, options.temperatureUnit);
+        case 'sensor':
+        case 'binary_sensor':
+            return mapSensor(entity);
+        case 'person':
+            return mapPerson(entity, options.assetUrl);
+        case 'weather':
+            return mapWeather(entity);
+        default:
+            if (SWITCH_DOMAINS.includes(domain)) {
+                return mapSwitch(entity);
+            }
+            if (ACTION_DOMAINS.includes(domain)) {
+                return mapAction(entity);
+            }
+            return mapGeneric(entity);
+    }
+}

package/dist/mappers/light.d.ts

@@ -0,0 +1,3 @@
+import type { EntityInput } from '@hashsome/core';
+import type { HassEntity } from 'home-assistant-js-websocket';
+export declare function mapLight(entity: HassEntity): EntityInput;

package/dist/mappers/light.js

@@ -0,0 +1,49 @@
+import { baseOf, num, strings } from './common.js';
+const COLOR_MODES = ['hs', 'xy', 'rgb', 'rgbw', 'rgbww'];
+function colorOf(a) {
+    const kelvin = num(a.color_temp_kelvin);
+    if (a.color_mode === 'color_temp' && kelvin !== undefined) {
+        return { mode: 'temperature', kelvin };
+    }
+    const hs = a.hs_color;
+    if (Array.isArray(hs) && typeof hs[0] === 'number' && typeof hs[1] === 'number') {
+        const rgb = a.rgb_color;
+        return {
+            mode: 'color',
+            hue: hs[0],
+            saturation: hs[1],
+            ...(Array.isArray(rgb) && rgb.length >= 3 && rgb.every((n) => typeof n === 'number')
+                ? { rgb: [rgb[0], rgb[1], rgb[2]] }
+                : {}),
+        };
+    }
+    return kelvin !== undefined ? { mode: 'temperature', kelvin } : undefined;
+}
+export function mapLight(entity) {
+    const a = entity.attributes;
+    const modes = strings(a.supported_color_modes);
+    const brightness = num(a.brightness);
+    const dimmable = modes.some((mode) => mode !== 'onoff' && mode !== 'unknown');
+    const colorTemperature = modes.includes('color_temp');
+    const color = colorOf(a);
+    return {
+        kind: 'light',
+        ...baseOf(entity),
+        on: entity.state === 'on',
+        ...(brightness !== undefined ? { brightness: brightness / 255 } : {}),
+        ...(color ? { color } : {}),
+        capabilities: {
+            brightness: dimmable,
+            colorTemperature,
+            color: modes.some((mode) => COLOR_MODES.includes(mode)),
+            ...(colorTemperature
+                ? {
+                    kelvinRange: {
+                        min: num(a.min_color_temp_kelvin) ?? 2000,
+                        max: num(a.max_color_temp_kelvin) ?? 6500,
+                    },
+                }
+                : {}),
+        },
+    };
+}

package/dist/mappers/media-player.d.ts

@@ -0,0 +1,3 @@
+import type { EntityInput } from '@hashsome/core';
+import type { HassEntity } from 'home-assistant-js-websocket';
+export declare function mapMediaPlayer(entity: HassEntity, toAssetUrl?: (path: string) => string): EntityInput;

package/dist/mappers/media-player.js

@@ -0,0 +1,69 @@
+import { baseOf, fileUrl, num, str } from './common.js';
+/** `MediaPlayerEntityFeature` bit flags from Home Assistant. */
+const FEATURE = {
+    seek: 2,
+    volumeSet: 4,
+    volumeMute: 8,
+    previous: 16,
+    next: 32,
+    shuffle: 32768,
+    browse: 131072,
+};
+const PLAYBACK = {
+    playing: 'playing',
+    paused: 'paused',
+    idle: 'idle',
+    standby: 'idle',
+    on: 'idle',
+    off: 'off',
+    buffering: 'buffering',
+};
+export function mapMediaPlayer(entity, toAssetUrl = (path) => path) {
+    const a = entity.attributes;
+    const features = num(a.supported_features);
+    const has = (flag, fallback) => features === undefined ? fallback : (features & flag) !== 0;
+    const volume = num(a.volume_level);
+    const title = str(a.media_title);
+    const artist = str(a.media_artist);
+    const album = str(a.media_album_name);
+    const picture = str(a.entity_picture_local) ?? str(a.entity_picture);
+    const artworkUrl = picture ? fileUrl(picture, toAssetUrl) : undefined;
+    const position = num(a.media_position);
+    const duration = num(a.media_duration);
+    const positionUpdatedAt = str(a.media_position_updated_at);
+    const shuffle = typeof a.shuffle === 'boolean' ? a.shuffle : undefined;
+    return {
+        kind: 'mediaPlayer',
+        ...baseOf(entity),
+        playback: PLAYBACK[entity.state] ?? 'idle',
+        muted: a.is_volume_muted === true,
+        ...(volume !== undefined ? { volume } : {}),
+        ...(title || artist || album || artworkUrl
+            ? {
+                media: {
+                    ...(title ? { title } : {}),
+                    ...(artist ? { artist } : {}),
+                    ...(album ? { album } : {}),
+                    ...(artworkUrl ? { artworkUrl } : {}),
+                },
+            }
+            : {}),
+        ...(shuffle !== undefined ? { shuffle } : {}),
+        ...(position !== undefined ? { position } : {}),
+        ...(duration !== undefined ? { duration } : {}),
+        ...(position !== undefined && positionUpdatedAt ? { positionUpdatedAt } : {}),
+        capabilities: {
+            volume: volume !== undefined || has(FEATURE.volumeSet, false),
+            mute: a.is_volume_muted !== undefined || has(FEATURE.volumeMute, false),
+            next: has(FEATURE.next, true),
+            previous: has(FEATURE.previous, true),
+            browse: has(FEATURE.browse, false),
+            // Home Assistant's browse contract has no search.
+            search: false,
+            seek: has(FEATURE.seek, false),
+            shuffle: has(FEATURE.shuffle, false),
+            transfer: false,
+            group: false,
+        },
+    };
+}

package/dist/mappers/simple.d.ts

@@ -0,0 +1,8 @@
+import type { EntityInput } from '@hashsome/core';
+import type { HassEntity } from 'home-assistant-js-websocket';
+export declare function mapSensor(entity: HassEntity): EntityInput;
+/** `on` for an on/off thing; for a lock, `locked`. */
+export declare function mapSwitch(entity: HassEntity): EntityInput;
+export declare function mapAction(entity: HassEntity): EntityInput;
+export declare function mapPerson(entity: HassEntity, toAssetUrl?: (path: string) => string): EntityInput;
+export declare function mapGeneric(entity: HassEntity): EntityInput;

package/dist/mappers/simple.js

@@ -0,0 +1,38 @@
+import { baseOf, fileUrl, num, str } from './common.js';
+export function mapSensor(entity) {
+    const unit = str(entity.attributes.unit_of_measurement);
+    const measurement = str(entity.attributes.device_class);
+    const numeric = entity.state.trim() === '' ? undefined : num(Number(entity.state));
+    return {
+        kind: 'sensor',
+        ...baseOf(entity),
+        value: entity.state,
+        ...(numeric !== undefined ? { numeric } : {}),
+        ...(unit ? { unit } : {}),
+        ...(measurement ? { measurement } : {}),
+    };
+}
+/** `on` for an on/off thing; for a lock, `locked`. */
+export function mapSwitch(entity) {
+    const on = entity.state === 'on' || entity.state === 'locked';
+    return { kind: 'switch', ...baseOf(entity), on };
+}
+export function mapAction(entity) {
+    const last = str(entity.attributes.last_triggered);
+    return { kind: 'action', ...baseOf(entity), ...(last ? { lastTriggered: last } : {}) };
+}
+export function mapPerson(entity, toAssetUrl = (path) => path) {
+    const raw = str(entity.attributes.entity_picture);
+    const picture = raw ? fileUrl(raw, toAssetUrl) : undefined;
+    return {
+        kind: 'person',
+        ...baseOf(entity),
+        location: entity.state,
+        home: entity.state === 'home',
+        ...(picture ? { pictureUrl: picture } : {}),
+    };
+}
+export function mapGeneric(entity) {
+    const unit = str(entity.attributes.unit_of_measurement);
+    return { kind: 'generic', ...baseOf(entity), value: entity.state, ...(unit ? { unit } : {}) };
+}

package/dist/mappers/weather.d.ts

@@ -0,0 +1,5 @@
+import { type EntityInput } from '@hashsome/core';
+import type { HassEntity } from 'home-assistant-js-websocket';
+/** A `weather.*` entity: its state is the current condition, its attributes the current readings
+ * (the forecast is separate, not part of the entity's state). */
+export declare function mapWeather(entity: HassEntity): EntityInput;

package/dist/mappers/weather.js

@@ -0,0 +1,19 @@
+import { WEATHER_CONDITIONS } from '@hashsome/core';
+import { baseOf, num, str } from './common.js';
+const isCondition = (state) => WEATHER_CONDITIONS.includes(state);
+/** A `weather.*` entity: its state is the current condition, its attributes the current readings
+ * (the forecast is separate, not part of the entity's state). */
+export function mapWeather(entity) {
+    const a = entity.attributes;
+    const temperature = num(a.temperature);
+    const unit = str(a.temperature_unit);
+    const humidity = num(a.humidity);
+    return {
+        kind: 'weather',
+        ...baseOf(entity),
+        condition: isCondition(entity.state) ? entity.state : 'unknown',
+        ...(temperature !== undefined ? { temperature } : {}),
+        ...(unit ? { unit } : {}),
+        ...(humidity !== undefined ? { humidity } : {}),
+    };
+}

package/dist/mock.d.ts

@@ -0,0 +1,11 @@
+import { MockIntegration, type EntityInput } from '@hashsome/core';
+export interface HomeAssistantMockOptions {
+    /** Integration id. Defaults to `ha`. */
+    id?: string;
+    /** Extra entities, by local id; they replace a default with the same id. */
+    entities?: Record<string, EntityInput>;
+}
+/** A Home Assistant integration that needs no Home Assistant: representative devices, mapped the
+ * same way real ones are, and commands that change their state. For tests, the gallery and
+ * dashboards under development. */
+export declare function createMock(options?: HomeAssistantMockOptions): MockIntegration;