@digital-alchemy/hass 24.9.4 → 24.10.1

package/src/extensions/entity.extension.ts

@@ -0,0 +1,347 @@
+import {
+  debounce,
+  each,
+  eachSeries,
+  INCREMENT,
+  is,
+  SECOND,
+  sleep,
+  START,
+  TServiceParams,
+} from "@digital-alchemy/core";
+import dayjs, { Dayjs } from "dayjs";
+
+import {
+  ALL_DOMAINS,
+  ANY_ENTITY,
+  EditLabelOptions,
+  ENTITY_REGISTRY_UPDATED,
+  ENTITY_STATE,
+  EntityHistoryDTO,
+  EntityHistoryItem,
+  EntityHistoryResult,
+  EntityRegistryItem,
+  HassEntityManager,
+  PICK_ENTITY,
+  TMasterState,
+} from "..";
+
+const MAX_ATTEMPTS = 10;
+const RECENT = 5;
+
+export function EntityManager({
+  logger,
+  hass,
+  config,
+  lifecycle,
+  event,
+  context,
+  internal,
+}: TServiceParams): HassEntityManager {
+  // #MARK: Local vars
+  /**
+   * MASTER_STATE.switch.desk_light = {entity_id,state,attributes,...}
+   */
+  let MASTER_STATE = {} as Partial<TMasterState>;
+  const PREVIOUS_STATE = new Map<ANY_ENTITY, ENTITY_STATE<ANY_ENTITY>>();
+  let lastRefresh: Dayjs;
+  function warnEarly(method: string) {
+    if (!init) {
+      lifecycle.onReady(() => {
+        if (config.boilerplate.LOG_LEVEL !== "trace") {
+          return;
+        }
+        logger.error(
+          "attempted to use [%s] before application booted. use {lifecycle.onReady}",
+          method,
+        );
+        // eslint-disable-next-line no-console
+        console.trace(method);
+      });
+    }
+  }
+
+  // * Local event emitter for coordination of socket events
+  // Other libraries will internally take advantage of this eventemitter
+  let init = false;
+
+  // #MARK: getCurrentState
+  function getCurrentState<ENTITY_ID extends ANY_ENTITY>(
+    entity_id: ENTITY_ID,
+  ): ENTITY_STATE<ENTITY_ID> {
+    const out = internal.utils.object.get(MASTER_STATE, entity_id) ?? {};
+    return out as ENTITY_STATE<ENTITY_ID>;
+  }
+
+  // #MARK: history
+  async function history<ENTITES extends ANY_ENTITY[]>(
+    payload: Omit<EntityHistoryDTO<ENTITES>, "type">,
+  ) {
+    logger.trace({ payload }, `looking up entity history`);
+    const result = (await hass.socket.sendMessage({
+      ...payload,
+      end_time: dayjs(payload.end_time).toISOString(),
+      start_time: dayjs(payload.start_time).toISOString(),
+      type: "history/history_during_period",
+    })) as Record<ANY_ENTITY, EntityHistoryItem[]>;
+
+    const entities = Object.keys(result) as ANY_ENTITY[];
+    return Object.fromEntries(
+      entities.map((entity_id: ANY_ENTITY) => {
+        const key = entity_id;
+        const states = result[entity_id];
+        const value = states.map(data => {
+          return {
+            attributes: data.a,
+            date: new Date(data.lu * SECOND),
+            state: data.s,
+          } as EntityHistoryResult;
+        });
+        return [key, value];
+      }),
+    );
+  }
+
+  // #MARK: listEntities
+  function listEntities<DOMAIN extends ALL_DOMAINS = ALL_DOMAINS>(
+    domain?: DOMAIN,
+  ): PICK_ENTITY<DOMAIN>[] {
+    if (domain) {
+      return Object.keys(MASTER_STATE[domain as ALL_DOMAINS]).map(
+        id => `${domain}.${id}` as PICK_ENTITY<DOMAIN>,
+      );
+    }
+    return Object.keys(MASTER_STATE).flatMap(domain =>
+      Object.keys(MASTER_STATE[domain as ALL_DOMAINS]).map(
+        id => `${domain}.${id}` as PICK_ENTITY<DOMAIN>,
+      ),
+    );
+  }
+
+  // #MARK: refresh
+  async function refresh(recursion = START): Promise<void> {
+    const now = dayjs();
+    if (lastRefresh) {
+      const diff = lastRefresh.diff(now, "ms");
+      if (diff >= RECENT * SECOND) {
+        logger.warn({ diff }, `multiple refreshes in close time`);
+      }
+    }
+    lastRefresh = now;
+    // - Fetch list of entities
+    const states = await hass.fetch.getAllEntities();
+
+    // - Keep retrying until max failures reached
+    if (!is.array(states) || is.empty(states)) {
+      if (recursion > MAX_ATTEMPTS) {
+        logger.fatal(
+          { name: refresh },
+          `failed to load service list from Home Assistant. validate configuration`,
+        );
+        process.exit();
+      }
+      logger.warn(
+        { name: refresh, response: states },
+        "failed to retrieve entity list. retrying {%s}/[%s]",
+        recursion,
+        MAX_ATTEMPTS,
+      );
+      await sleep(config.hass.RETRY_INTERVAL * SECOND);
+      await refresh(recursion + INCREMENT);
+      return;
+    }
+
+    // - Preserve old state for comparison
+    const oldState = MASTER_STATE;
+    MASTER_STATE = {};
+    const emitUpdates: ENTITY_STATE<ANY_ENTITY>[] = [];
+
+    // - Go through all entities, setting the state
+    // ~ If this is a refresh (not an initial boot), track what changed so events can be emitted
+    states.forEach(entity => {
+      // ? Set first, ensure data is populated
+      // `nextTick` will fire AFTER loop finishes
+      internal.utils.object.set(
+        MASTER_STATE,
+        entity.entity_id,
+        entity,
+        is.undefined(internal.utils.object.get(oldState, entity.entity_id)),
+      );
+      if (!init) {
+        return;
+      }
+      const old = internal.utils.object.get(oldState, entity.entity_id);
+      if (is.equal(old, entity)) {
+        // logger.trace(
+        //   { entity_id: entity.entity_id, name: refresh },
+        //   `no change on refresh`,
+        // );
+        return;
+      }
+      emitUpdates.push(entity);
+    });
+
+    // Attempt to not blow up the system?
+    // TODO: does this gain anything? is a debounce needed somewhere else instead?
+    setImmediate(async () => {
+      await each(
+        emitUpdates,
+        async entity =>
+          await entityUpdateReceiver(
+            entity.entity_id,
+            entity satisfies ENTITY_STATE<ANY_ENTITY>,
+            internal.utils.object.get(oldState, entity.entity_id),
+          ),
+      );
+    });
+    init = true;
+  }
+
+  // #MARK: EntityUpdateReceiver
+  function entityUpdateReceiver<ENTITY extends ANY_ENTITY = ANY_ENTITY>(
+    entity_id: ENTITY,
+    new_state: ENTITY_STATE<ENTITY>,
+    old_state: ENTITY_STATE<ENTITY>,
+  ) {
+    PREVIOUS_STATE.set(entity_id, old_state);
+    if (new_state === null) {
+      logger.warn(
+        { name: entityUpdateReceiver },
+        `removing deleted entity [%s] from {MASTER_STATE}`,
+        entity_id,
+      );
+      internal.utils.object.del(MASTER_STATE, entity_id);
+      return;
+    }
+    internal.utils.object.set(MASTER_STATE, entity_id, new_state);
+    if (!hass.socket.pauseMessages) {
+      event.emit(entity_id, new_state, old_state);
+      const unique_id = hass.entity.registry.current.find(
+        i => i.entity_id === entity_id,
+      )?.unique_id;
+      if (is.number(unique_id) || !is.empty(unique_id)) {
+        event.emit(unique_id, new_state, old_state);
+      }
+    }
+  }
+
+  // #MARK: onPostConfig
+  lifecycle.onPostConfig(async function HassEntityPostConfig() {
+    logger.debug({ name: HassEntityPostConfig }, `pre populate {MASTER_STATE}`);
+    await hass.entity.refresh();
+  });
+
+  async function AddLabel({ entity, label }: EditLabelOptions) {
+    await each([entity].flat(), async entity => {
+      const current = await entityGet(entity);
+      if (current?.labels?.includes(label)) {
+        logger.debug({ name: entity }, `already has label {%s}`, label);
+        return;
+      }
+      return await new Promise<void>(async done => {
+        event.once(ENTITY_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          entity_id: entity,
+          labels: [...current.labels, label],
+          type: "config/entity_registry/update",
+        });
+      });
+    });
+  }
+
+  // #MARK: EntitySource
+  async function EntitySource() {
+    return await hass.socket.sendMessage<Record<ANY_ENTITY, { domain: string }>>({
+      type: "entity/source",
+    });
+  }
+
+  // #MARK: EntityList
+  async function EntityList() {
+    return await hass.socket.sendMessage<EntityRegistryItem<ANY_ENTITY>[]>({
+      type: "config/entity_registry/list",
+    });
+  }
+
+  // #MARK: RemoveLabel
+  async function RemoveLabel({ entity, label }: EditLabelOptions) {
+    const current = await entityGet(entity);
+    if (!current?.labels?.includes(label)) {
+      logger.debug({ name: entity }, `does not have label {%s}`, label);
+      return;
+    }
+    logger.debug({ name: entity }, `removing label [%s]`, label);
+    return await new Promise<void>(async done => {
+      event.once(ENTITY_REGISTRY_UPDATED, done);
+      await hass.socket.sendMessage({
+        entity_id: entity,
+        labels: current.labels.filter(i => i !== label),
+        type: "config/entity_registry/update",
+      });
+    });
+  }
+
+  // #MARK: EntityGet
+  async function entityGet<ENTITY extends ANY_ENTITY>(entity_id: ENTITY) {
+    return await hass.socket.sendMessage<EntityRegistryItem<ENTITY>>({
+      entity_id: entity_id,
+      type: "config/entity_registry/get",
+    });
+  }
+
+  // #MARK: onConnect
+  hass.socket.onConnect(async () => {
+    hass.socket.subscribe({
+      context,
+      event_type: "entity_registry_updated",
+      async exec() {
+        await debounce(ENTITY_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
+        logger.debug("entity registry updated");
+        hass.entity.registry.current = await hass.entity.registry.list();
+        event.emit(ENTITY_REGISTRY_UPDATED);
+      },
+    });
+    hass.entity.registry.current = await hass.entity.registry.list();
+  });
+
+  // #MARK: RemoveEntity
+  async function RemoveEntity(entity_id: ANY_ENTITY | ANY_ENTITY[]) {
+    warnEarly("RemoveEntity");
+    await eachSeries([entity_id].flat(), async entity_id => {
+      logger.debug({ name: entity_id }, `removing entity`);
+      await hass.socket.sendMessage({
+        entity_id,
+        type: "config/entity_registry/remove",
+      });
+    });
+  }
+
+  // #MARK: return object
+  return {
+    _entityUpdateReceiver: entityUpdateReceiver,
+
+    _masterState: () => MASTER_STATE,
+
+    /**
+     * Retrieves the current state of a given entity. This method returns
+     * raw data, offering a direct view of the entity's state at a given moment.
+     */
+    getCurrentState,
+
+    history,
+    listEntities,
+    previousState: (entity_id: ANY_ENTITY) => PREVIOUS_STATE.get(entity_id),
+    refresh,
+    registry: {
+      addLabel: AddLabel,
+      current: [] as EntityRegistryItem<ANY_ENTITY>[],
+      get: entityGet,
+      list: EntityList,
+      registryList: EntityList,
+      removeEntity: RemoveEntity,
+      removeLabel: RemoveLabel,
+      source: EntitySource,
+    },
+    warnEarly,
+  };
+}

package/src/extensions/events.extension.ts

@@ -0,0 +1,25 @@
+import { TServiceParams } from "@digital-alchemy/core";
+
+import {
+  AREA_REGISTRY_UPDATED,
+  DEVICE_REGISTRY_UPDATED,
+  ENTITY_REGISTRY_UPDATED,
+  FLOOR_REGISTRY_UPDATED,
+  HassEventsService,
+  LABEL_REGISTRY_UPDATED,
+  SimpleCallback,
+  ZONE_REGISTRY_UPDATED,
+} from "../helpers";
+
+export function Events({ event }: TServiceParams): HassEventsService {
+  return {
+    onAreaRegistryUpdate: (callback: SimpleCallback) => event.on(AREA_REGISTRY_UPDATED, callback),
+    onDeviceRegistryUpdate: (callback: SimpleCallback) =>
+      event.on(DEVICE_REGISTRY_UPDATED, callback),
+    onEntityRegistryUpdate: (callback: SimpleCallback) =>
+      event.on(ENTITY_REGISTRY_UPDATED, callback),
+    onFloorRegistryUpdate: (callback: SimpleCallback) => event.on(FLOOR_REGISTRY_UPDATED, callback),
+    onLabelRegistryUpdate: (callback: SimpleCallback) => event.on(LABEL_REGISTRY_UPDATED, callback),
+    onZoneRegistryUpdate: (callback: SimpleCallback) => event.on(ZONE_REGISTRY_UPDATED, callback),
+  };
+}

package/src/extensions/fetch-api.extension.ts

@@ -0,0 +1,269 @@
+import { DOWN, is, NO_CHANGE, SECOND, TServiceParams, UP } from "@digital-alchemy/core";
+import dayjs, { Dayjs } from "dayjs";
+import { lt } from "semver";
+
+import {
+  ALL_SERVICE_DOMAINS,
+  ANY_ENTITY,
+  CalendarEvent,
+  CalendarFetchOptions,
+  CheckConfigResult,
+  ENTITY_STATE,
+  FetchArguments,
+  FilteredFetchArguments,
+  HassConfig,
+  HassServiceDTO,
+  HomeAssistantServerLogItem,
+  MIN_SUPPORTED_HASS_VERSION,
+  PICK_SERVICE,
+  PICK_SERVICE_PARAMETERS,
+  PostConfigPriorities,
+  RawCalendarEvent,
+  TFetchBody,
+} from "..";
+
+type SendBody<STATE extends string | number = string, ATTRIBUTES extends object = object> = {
+  attributes?: ATTRIBUTES;
+  state?: STATE;
+};
+
+export function FetchAPI({ logger, lifecycle, context, hass, config }: TServiceParams) {
+  const fetcher = hass.internals({ context });
+  const { download: downloader } = fetcher;
+
+  // Load configurations
+  lifecycle.onPostConfig(() => {
+    fetcher.base_url = config.hass.BASE_URL;
+    fetcher.base_headers = { Authorization: `Bearer ${config.hass.TOKEN}` };
+  }, PostConfigPriorities.FETCH);
+
+  lifecycle.onBootstrap(async () => {
+    const target = await hass.fetch.getConfig();
+    if (lt(target.version, MIN_SUPPORTED_HASS_VERSION)) {
+      logger.fatal(
+        { target: target.version },
+        "minimum supported version of home assistant: %s",
+        MIN_SUPPORTED_HASS_VERSION,
+      );
+      process.exit();
+    }
+    logger.debug(`hass version %s`, target.version);
+  });
+
+  async function calendarSearch({
+    calendar,
+    start = dayjs(),
+    end,
+  }: CalendarFetchOptions): Promise<CalendarEvent[]> {
+    if (Array.isArray(calendar)) {
+      const list = await Promise.all(
+        calendar.map(async cal => await calendarSearch({ calendar: cal, end, start })),
+      );
+      return list.flat().sort((a, b) =>
+        // eslint-disable-next-line sonarjs/no-nested-conditional
+        a.start.isSame(b.start) ? NO_CHANGE : a.start.isAfter(b.start) ? UP : DOWN,
+      );
+    }
+
+    const params = { end: end.toISOString(), start: start.toISOString() };
+    const events = await hass.fetch.fetch<RawCalendarEvent[]>({
+      params,
+      url: `/api/calendars/${encodeURIComponent(calendar)}`,
+    });
+    logger.trace(
+      { name: calendarSearch, params },
+      `%s search found %s events`,
+      calendar,
+      events.length,
+    );
+    return events.map(({ start, end, ...extra }) => ({
+      ...extra,
+      end: dayjs(end.dateTime),
+      start: dayjs(start.dateTime),
+    }));
+  }
+
+  async function callService<
+    DOMAIN extends ALL_SERVICE_DOMAINS,
+    SERVICE extends PICK_SERVICE<DOMAIN>,
+  >(serviceName: SERVICE, data: PICK_SERVICE_PARAMETERS<DOMAIN, SERVICE>): Promise<void> {
+    const [domain, service] = serviceName.split(".");
+    await hass.fetch.fetch({
+      body: data as TFetchBody,
+      method: "post",
+      url: `/api/services/${domain}/${service}`,
+    });
+  }
+
+  async function checkConfig(): Promise<CheckConfigResult> {
+    logger.trace({ name: checkConfig }, `send`);
+    return await hass.fetch.fetch({
+      method: `post`,
+      url: `/api/config/core/check_config`,
+    });
+  }
+
+  async function download(destination: string, fetchWith: FilteredFetchArguments): Promise<void> {
+    logger.trace({ name: download }, `send`);
+    await downloader({
+      ...fetchWith,
+      baseUrl: config.hass.BASE_URL,
+      destination,
+      headers: { Authorization: `Bearer ${config.hass.TOKEN}` },
+    });
+  }
+
+  async function fetchEntityCustomizations<
+    T extends Record<never, unknown> = Record<"global" | "local", Record<string, string>>,
+  >(entityId: ANY_ENTITY): Promise<T> {
+    logger.trace({ name: fetchEntityCustomizations }, `send`);
+    return await hass.fetch.fetch<T>({
+      url: `/api/config/customize/config/${encodeURIComponent(entityId)}`,
+    });
+  }
+
+  async function fetchEntityHistory<
+    ENTITY extends ANY_ENTITY = ANY_ENTITY,
+    T extends ENTITY_STATE<ENTITY> = ENTITY_STATE<ENTITY>,
+  >(
+    entity_id: ENTITY,
+    from: Date | Dayjs,
+    to: Date | Dayjs,
+    extra: { minimal_response?: "" } = {},
+  ): Promise<T[]> {
+    logger.info(
+      {
+        entity_id,
+        from: dayjs(from).toISOString(),
+        name: fetchEntityHistory,
+        to: dayjs(to).toISOString(),
+      },
+      `fetch entity history`,
+    );
+    const result = await hass.fetch.fetch<[T[]]>({
+      params: {
+        end_time: to.toISOString(),
+        filter_entity_id: entity_id,
+        ...extra,
+      },
+      url: `/api/history/period/${encodeURIComponent(from.toISOString())}`,
+    });
+    if (!Array.isArray(result)) {
+      logger.error({ name: fetchEntityHistory, result }, `unexpected return result`);
+      return [];
+    }
+    const [out] = result;
+    return out;
+  }
+
+  async function fireEvent<DATA extends TFetchBody = object>(
+    event: string,
+    data?: DATA,
+  ): Promise<void> {
+    logger.trace({ data, event, name: fireEvent }, `firing event`);
+    const response = await hass.fetch.fetch<{ message: string }, DATA>({
+      body: data,
+      method: "post",
+      url: `/api/events/${encodeURIComponent(event)}`,
+    });
+    if (response?.message !== `Event ${event} fired.`) {
+      logger.debug({ name: fetchEntityHistory, response }, `unexpected response from firing event`);
+    }
+  }
+
+  async function getAllEntities(): Promise<ENTITY_STATE<ANY_ENTITY>[]> {
+    logger.trace({ name: getAllEntities }, `send`);
+    return await hass.fetch.fetch<ENTITY_STATE<ANY_ENTITY>[]>({
+      url: `/api/states`,
+    });
+  }
+
+  async function getConfig(): Promise<HassConfig> {
+    logger.trace({ name: getConfig }, `send`);
+    return await hass.fetch.fetch({ url: `/api/config` });
+  }
+
+  async function getLogs(): Promise<HomeAssistantServerLogItem[]> {
+    logger.trace({ name: getLogs }, `send`);
+    const results = await hass.fetch.fetch<HomeAssistantServerLogItem[]>({
+      url: `/api/error/all`,
+    });
+    return results.map(i => {
+      i.timestamp = Math.floor(i.timestamp * SECOND);
+      i.first_occurred = Math.floor(i.first_occurred * SECOND);
+      return i;
+    });
+  }
+
+  async function getRawLogs(): Promise<string> {
+    logger.trace({ name: getRawLogs }, `send`);
+    return await hass.fetch.fetch<string>({
+      process: "text",
+      url: `/api/error_log`,
+    });
+  }
+
+  async function listServices(): Promise<HassServiceDTO[]> {
+    logger.trace({ name: listServices }, `send`);
+    return await hass.fetch.fetch<HassServiceDTO[]>({ url: `/api/services` });
+  }
+
+  async function updateEntity<
+    STATE extends string | number = string,
+    ATTRIBUTES extends object = object,
+  >(entity_id: ANY_ENTITY, { attributes, state }: SendBody<STATE, ATTRIBUTES>): Promise<void> {
+    const body: SendBody<STATE> = {};
+    // ! ORDER MATTERS FOR APPLYING
+    // Must be applied in alphabetical order for unit test reasons
+    if (!is.empty(attributes)) {
+      body.attributes = attributes;
+    }
+    if (state !== undefined) {
+      body.state = state;
+    }
+    logger.trace({ ...body, entity_id, name: updateEntity }, `set entity state`);
+    await hass.fetch.fetch({
+      body,
+      method: "post",
+      url: `/api/states/${encodeURIComponent(entity_id)}`,
+    });
+  }
+
+  async function webhook(webhook_name: string, data: object = {}): Promise<void> {
+    logger.trace({ data, name: webhook, webhook_name }, `send`);
+    await hass.fetch.fetch({
+      body: data,
+      method: "post",
+      process: "text",
+      url: `/api/webhook/${encodeURIComponent(webhook_name)}`,
+    });
+  }
+
+  async function checkCredentials(): Promise<{ message: string } | string> {
+    logger.trace({ name: checkCredentials }, `send`);
+    return await hass.fetch.fetch({
+      url: `/api/`,
+    });
+  }
+
+  return {
+    _fetcher: fetcher,
+    calendarSearch,
+    callService,
+    checkConfig,
+    checkCredentials,
+    download,
+    fetch: async <T, BODY extends TFetchBody = undefined>(options: Partial<FetchArguments<BODY>>) =>
+      await fetcher.exec<T, BODY>(options),
+    fetchEntityCustomizations,
+    fetchEntityHistory,
+    fireEvent,
+    getAllEntities,
+    getConfig,
+    getLogs,
+    getRawLogs,
+    listServices,
+    updateEntity,
+    webhook,
+  };
+}

package/src/extensions/floor.extension.ts

@@ -0,0 +1,76 @@
+import { debounce, TServiceParams } from "@digital-alchemy/core";
+
+import { TFloorId } from "../dynamic";
+import {
+  EARLY_ON_READY,
+  FLOOR_REGISTRY_UPDATED,
+  FloorCreate,
+  FloorDetails,
+  HassFloorService,
+} from "../helpers";
+
+export function Floor({
+  hass,
+  config,
+  context,
+  event,
+  logger,
+  lifecycle,
+}: TServiceParams): HassFloorService {
+  hass.socket.onConnect(async () => {
+    let loading = new Promise<void>(async done => {
+      hass.floor.current = await hass.floor.list();
+      loading = undefined;
+      done();
+    });
+    lifecycle.onReady(async () => loading && (await loading), EARLY_ON_READY);
+
+    hass.socket.subscribe({
+      context,
+      event_type: "floor_registry_updated",
+      async exec() {
+        await debounce(FLOOR_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
+        hass.floor.current = await hass.floor.list();
+        logger.debug(`floor registry updated`);
+        event.emit(FLOOR_REGISTRY_UPDATED);
+      },
+    });
+  });
+
+  return {
+    async create(details: FloorCreate) {
+      return await new Promise<void>(async done => {
+        event.once(FLOOR_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          aliases: [],
+          type: "config/floor_registry/create",
+          ...details,
+        });
+      });
+    },
+    current: [] as FloorDetails[],
+    async delete(floor_id: TFloorId) {
+      return await new Promise<void>(async done => {
+        event.once(FLOOR_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          floor_id,
+          type: "config/floor_registry/delete",
+        });
+      });
+    },
+    async list() {
+      return await hass.socket.sendMessage<FloorDetails[]>({
+        type: "config/floor_registry/list",
+      });
+    },
+    async update(details: FloorDetails) {
+      return await new Promise<void>(async done => {
+        event.once(FLOOR_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          type: "config/floor_registry/update",
+          ...details,
+        });
+      });
+    },
+  };
+}