@glasshome/sync-layer 0.7.2 → 0.8.1

package/dist/service-C8H42I-Q.d.ts

@@ -0,0 +1,459 @@
+import { AreaEntry, DeviceEntry, Domain, EntityCategory, EntityRegistryEntry, ServiceCall, ServiceName, WsCommandType } from "@glasshome/ha-types";
+//#region src/core/types.d.ts
+/**
+ * Unique entity identifier (e.g., "light.living_room")
+ */
+type EntityId = string;
+/**
+ * Domain extracted from entity_id (e.g., "light")
+ */
+type EntityDomain = string;
+/**
+ * Unique device identifier (UUID)
+ */
+type DeviceId = string;
+/**
+ * Unique area identifier
+ */
+type AreaId = string;
+/**
+ * Floor identifier
+ */
+type FloorId = string;
+/**
+ * Label identifier
+ */
+type LabelId = string;
+/**
+ * Runtime entity state from Home Assistant
+ *
+ * This represents the live state of an entity as received
+ * from the WebSocket API's `get_states` command or `subscribe_entities` subscription.
+ */
+interface HassEntity {
+  /** Unique entity identifier */
+  entity_id: EntityId;
+  /** Current state value (e.g., "on", "off", "23.5") */
+  state: string;
+  /** Entity attributes (brightness, temperature, etc.) */
+  attributes: Record<string, any>;
+  /** ISO 8601 timestamp of last state change */
+  last_changed: string;
+  /** ISO 8601 timestamp of last update */
+  last_updated: string;
+  /** Event context */
+  context: {
+    /** Context ID */
+    id: string;
+    /** Parent context ID */
+    parent_id: string | null;
+    /** User ID that triggered the change */
+    user_id: string | null;
+  };
+}
+/**
+ * Device registry entry
+ *
+ * @alias DeviceEntry
+ */
+type DeviceRegistryEntry = DeviceEntry;
+/**
+ * Area registry entry
+ *
+ * @alias AreaEntry
+ * @note AreaEntry uses 'id' field, not 'area_id'
+ */
+type AreaRegistryEntry = AreaEntry;
+/**
+ * Floor registry entry
+ *
+ * Response structure from `config/floor_registry/list`
+ */
+interface FloorRegistryEntry {
+  /** Unique floor identifier */
+  floor_id: FloorId;
+  /** Floor name */
+  name: string;
+  /** Floor level (integer, 0 = ground floor) */
+  level: number;
+  /** Floor icon */
+  icon: string | null;
+  /** Floor aliases */
+  aliases: string[];
+  /** Created timestamp */
+  created_at: string;
+  /** Modified timestamp */
+  modified_at: string;
+}
+/**
+ * Label registry entry
+ *
+ * Response structure from `config/label_registry/list`
+ */
+interface LabelRegistryEntry {
+  /** Unique label identifier */
+  label_id: LabelId;
+  /** Label name */
+  name: string;
+  /** Label color (hex) */
+  color: string | null;
+  /** Label icon */
+  icon: string | null;
+  /** Label description */
+  description: string | null;
+  /** Created timestamp */
+  created_at: string;
+  /** Modified timestamp */
+  modified_at: string;
+}
+/**
+ * Statistics metadata
+ *
+ * Response structure from `recorder/get_statistics_metadata`
+ */
+interface StatisticMetadata {
+  /** Statistic ID */
+  statistic_id: string;
+  /** Data source */
+  source: string;
+  /** Unit of measurement */
+  unit_of_measurement: string | null;
+  /** Whether statistic has mean values */
+  has_mean: boolean;
+  /** Whether statistic has sum values */
+  has_sum: boolean;
+  /** Display name */
+  name: string | null;
+}
+/**
+ * Statistics data point
+ *
+ * Response structure from `recorder/statistics_during_period`
+ */
+interface StatisticData {
+  /** Statistic ID */
+  statistic_id: string;
+  /** Period start (ISO 8601) */
+  start: string;
+  /** Period end (ISO 8601) */
+  end: string;
+  /** Mean value */
+  mean?: number;
+  /** Minimum value */
+  min?: number;
+  /** Maximum value */
+  max?: number;
+  /** Last reset timestamp */
+  last_reset?: string;
+  /** State value */
+  state?: number;
+  /** Sum value */
+  sum?: number;
+}
+/**
+ * Unified entity view combining runtime state and registry metadata
+ *
+ * This is the primary interface for working with entities in the sync-layer.
+ * It combines live state data with registry metadata to provide a complete
+ * view of an entity.
+ */
+interface EntityView {
+  /** Unique entity identifier */
+  id: EntityId;
+  /** Entity domain (e.g., "light", "sensor") */
+  domain: EntityDomain;
+  /** Current state value */
+  state: string;
+  /**
+   * Entity attributes from Home Assistant, excluding keys that are
+   * surfaced as canonical resolved fields elsewhere on EntityView
+   * (`deviceClass`, `unitOfMeasurement`, `friendlyName`, `icon`).
+   * Use those fields instead of reaching into `attributes`.
+   */
+  attributes: Omit<Record<string, any>, "device_class" | "unit_of_measurement" | "friendly_name" | "icon">;
+  lastChanged: Date;
+  lastUpdated: Date;
+  /** Event context */
+  context: {
+    id: string;
+    parentId: string | null;
+    userId: string | null;
+  };
+  /** Entity name (from registry or friendly_name) */
+  name: string;
+  /** Friendly display name */
+  friendlyName: string;
+  /** Area ID where entity is located */
+  areaId: AreaId | null;
+  /** Device ID this entity belongs to */
+  deviceId: DeviceId | null;
+  /** Platform/integration that provides this entity */
+  platform: string;
+  /** Unique ID from integration */
+  uniqueId: string | null;
+  /** Whether entity is disabled */
+  isDisabled: boolean;
+  /** Whether entity is hidden */
+  isHidden: boolean;
+  /** Resolved icon (registry icon, attribute icon, or domain default) */
+  icon: string | null;
+  /** Icon source (registry, attribute, or default) */
+  iconSource: "registry" | "attribute" | "default";
+  /** Entity category (config, diagnostic, or null) */
+  entityCategory: EntityCategory | null;
+  /** Labels applied to this entity */
+  labels: LabelId[];
+  /** Entity aliases */
+  aliases: string[];
+  /** Device class (e.g., "temperature", "humidity") */
+  deviceClass?: string | null;
+  /** Unit of measurement */
+  unitOfMeasurement?: string | null;
+  /** Supported features bitmask */
+  supportedFeatures?: number;
+}
+/**
+ * Device view combining registry data with computed properties
+ */
+interface DeviceView {
+  /** Unique device identifier */
+  id: DeviceId;
+  /** Device name */
+  name: string;
+  /** User-friendly name */
+  nameByUser: string | null;
+  /** Manufacturer */
+  manufacturer: string | null;
+  /** Model */
+  model: string | null;
+  /** Software version */
+  swVersion: string | null;
+  /** Area ID where device is located */
+  areaId: AreaId | null;
+  /** Configuration entry IDs */
+  configEntries: string[];
+  /** Device connections */
+  connections: Array<[string, string]>;
+  /** Device identifiers */
+  identifiers: Array<[string, string]>;
+  /** Whether device is disabled */
+  disabledBy: string | null;
+}
+/**
+ * Area view combining registry data with computed entities and devices
+ */
+interface AreaView {
+  /** Unique area identifier */
+  id: AreaId;
+  /** Area name */
+  name: string;
+  /** Normalized area name (for searching) */
+  normalizedName: string;
+  /** Area aliases */
+  aliases: string[];
+  /** Floor ID this area belongs to */
+  floorId: FloorId | null;
+  /** Area icon */
+  icon: string | null;
+  /** Area picture */
+  picture: string | null;
+  /** Labels applied to this area */
+  labels: LabelId[];
+  /** Temperature entity ID for this area */
+  temperatureEntityId: EntityId | null;
+  /** Humidity entity ID for this area */
+  humidityEntityId: EntityId | null;
+  /** Created timestamp */
+  createdAt: string;
+  /** Last modified timestamp */
+  modifiedAt: string;
+  /** Entities in this area (direct + via devices) - uses query engine */
+  entities: EntityView[];
+  /** Devices in this area */
+  devices: DeviceView[];
+  /** Entity IDs for fast lookups */
+  entityIds: EntityId[];
+  /** Device IDs for fast lookups */
+  deviceIds: DeviceId[];
+}
+/**
+ * WebSocket connection state
+ */
+type ConnectionState = "connecting" | "connected" | "disconnected" | "reconnecting" | "error";
+/**
+ * Unsubscribe function returned by subscriptions
+ */
+type UnsubscribeFunc = () => void;
+/**
+ * Generic callback type
+ */
+type Callback<T> = (data: T) => void;
+/**
+ * Predicate function for filtering
+ */
+type PredicateFunc<T> = (item: T) => boolean;
+/**
+ * Mapping function for transformations
+ */
+type MapFunc<T, R> = (item: T) => R;
+/**
+ * Extract domain from entity ID
+ */
+declare function extractDomain(entityId: EntityId): EntityDomain;
+//#endregion
+//#region src/calendar/types.d.ts
+/**
+ * One calendar event as HA serializes it over `calendar/event/subscribe`:
+ * dates/datetimes are ISO strings (date-only for all-day events), and
+ * None-valued fields are omitted.
+ */
+interface CalendarEvent {
+  start: string;
+  end: string;
+  summary: string;
+  description?: string;
+  location?: string;
+  uid?: string;
+  recurrence_id?: string;
+  rrule?: string;
+}
+/** Live event window for one calendar entity, held in the store. */
+interface CalendarEventsData {
+  entityId: EntityId;
+  events: CalendarEvent[];
+  /** True until the first snapshot for the current subscription arrives. */
+  loading: boolean;
+  error: Error | null;
+  /** Subscribed window bounds (ISO). */
+  start: string;
+  end: string;
+}
+/** Per-tracker window request, in whole days relative to now. */
+interface CalendarWindowOptions {
+  daysBehind?: number;
+  daysAhead?: number;
+}
+//#endregion
+//#region src/commands/types.d.ts
+/**
+ * Service call target
+ *
+ * Defines what entities the service call should affect
+ */
+interface ServiceTarget {
+  /** Entity IDs */
+  entity_id?: string | string[];
+  /** Device IDs */
+  device_id?: string | string[];
+  /** Area IDs */
+  area_id?: string | string[];
+}
+/**
+ * Service call with full context
+ */
+interface ServiceCallContext {
+  /** Domain (e.g., "light", "switch") */
+  domain: Domain;
+  /** Service name (e.g., "turn_on", "toggle") */
+  service: ServiceName<Domain>;
+  /** Service data */
+  serviceData?: ServiceCall<Domain, ServiceName<Domain>>;
+  /** Target entities/devices/areas */
+  target?: ServiceTarget;
+}
+/**
+ * Command success result
+ */
+interface CommandSuccess<T = unknown> {
+  success: true;
+  result: T;
+}
+/**
+ * Command error result
+ */
+interface CommandError {
+  success: false;
+  error: {
+    code: string;
+    message: string;
+  };
+}
+/**
+ * Command result (success or error)
+ */
+type CommandResult<T = unknown> = CommandSuccess<T> | CommandError;
+/**
+ * Entity registry update fields
+ *
+ * Fields that can be updated in the entity registry
+ */
+interface EntityUpdateFields {
+  /** Friendly name */
+  name?: string;
+  /** Icon */
+  icon?: string;
+  /** Area ID */
+  area_id?: string | null;
+  /** Disabled by (null to enable) */
+  disabled_by?: string | null;
+  /** Hidden by (null to unhide) */
+  hidden_by?: string | null;
+}
+/**
+ * Command execution options
+ */
+interface CommandOptions {
+  /** Timeout in milliseconds */
+  timeout?: number;
+  /** Retry on failure */
+  retry?: boolean;
+  /** Number of retry attempts */
+  retries?: number;
+}
+//#endregion
+//#region src/commands/service.d.ts
+/**
+ * Call a Home Assistant service
+ */
+declare function callService<D extends Domain, S extends ServiceName<D>>(domain: D, service: S, serviceData?: ServiceCall<D, S>, target?: ServiceTarget): Promise<void>;
+/**
+ * Turn on entity or entities
+ */
+declare function turnOn(entityId: EntityId | EntityId[], serviceData?: Record<string, any>): Promise<void>;
+/**
+ * Turn off entity or entities
+ */
+declare function turnOff(entityId: EntityId | EntityId[], serviceData?: Record<string, any>): Promise<void>;
+/**
+ * Toggle entity or entities
+ */
+declare function toggle(entityId: EntityId | EntityId[], serviceData?: Record<string, any>): Promise<void>;
+/**
+ * Update entity registry entry
+ */
+declare function updateEntity(entityId: EntityId, updates: EntityUpdateFields): Promise<any>;
+/**
+ * Send a generic WebSocket command
+ */
+declare function sendCommand<T = unknown>(command: {
+  type: WsCommandType | string;
+  [key: string]: unknown;
+}): Promise<T>;
+/**
+ * Execute multiple service calls in parallel
+ */
+declare function batchServiceCalls(calls: Array<{
+  domain: Domain;
+  service: ServiceName<Domain>;
+  serviceData?: ServiceCall<Domain, ServiceName<Domain>>;
+  target?: ServiceTarget;
+}>): Promise<void>;
+/**
+ * Execute multiple entity updates in parallel
+ */
+declare function batchEntityUpdates(updates: Array<{
+  entityId: EntityId;
+  updates: EntityUpdateFields;
+}>): Promise<any[]>;
+//#endregion
+export { HassEntity as A, DeviceRegistryEntry as C, EntityView as D, EntityId as E, StatisticData as F, StatisticMetadata as I, UnsubscribeFunc as L, LabelRegistryEntry as M, MapFunc as N, FloorId as O, PredicateFunc as P, extractDomain as R, DeviceId as S, EntityDomain as T, AreaId as _, toggle as a, Callback as b, updateEntity as c, EntityUpdateFields as d, ServiceCallContext as f, CalendarWindowOptions as g, CalendarEventsData as h, sendCommand as i, LabelId as j, FloorRegistryEntry as k, CommandOptions as l, CalendarEvent as m, batchServiceCalls as n, turnOff as o, ServiceTarget as p, callService as r, turnOn as s, batchEntityUpdates as t, CommandResult as u, AreaRegistryEntry as v, DeviceView as w, ConnectionState as x, AreaView as y };

package/dist/solid/index.d.ts

@@ -1,10 +1,123 @@
+import { a as toggle, g as CalendarWindowOptions, h as CalendarEventsData, o as turnOff, r as callService, s as turnOn } from "../service-C8H42I-Q.js";
+import { Accessor, Resource } from "solid-js";
+import { HassConfig, HassUnitSystem } from "@glasshome/ha-types";
+import { AreaView, CameraStreamData, ConnectionState, EntityHistoryData, EntityView, GlassHomeState, HassEntity, StatisticValue, StatisticsQueryOptions, WeatherForecastsData } from "@glasshome/sync-layer";
+//#region src/solid/hooks.d.ts
 /**
- * SolidJS Adapter for @glasshome/sync-layer
+ * Get a reactive EntityView for an entity ID.
  *
- * Thin reactive layer over the native SolidJS store.
- * Import from `@glasshome/sync-layer/solid`.
+ * Registers the entity for live updates via the subscription manager.
+ * Only re-runs when the specific entity's data changes.
+ */
+declare function useEntity(entityId: Accessor<string> | string): Accessor<EntityView | undefined>;
+/**
+ * Get reactive EntityViews for multiple entity IDs.
+ *
+ * Registers all entity IDs for live updates via the subscription manager.
+ */
+declare function useEntities(entityIds: Accessor<string[]>): Accessor<EntityView[]>;
+/**
+ * Get raw HassEntity state (without EntityView transformation).
+ *
+ * Registers the entity for live updates via the subscription manager.
+ */
+declare function useEntityState(entityId: Accessor<string> | string): Accessor<HassEntity | undefined>;
+/**
+ * Get reactive connection status.
+ */
+declare function useConnection(): {
+  status: Accessor<ConnectionState>;
+  isConnected: Accessor<boolean>;
+};
+/** Reactive Home Assistant core config (null until loaded). */
+declare function useHassConfig(): Accessor<HassConfig | null>;
+/** Reactive HA unit system (length/mass/temperature/volume), or null until loaded. */
+declare function useUnitSystem(): Accessor<HassUnitSystem | null>;
+/** Reactive temperature unit from HA config, including the degree sign. Defaults to "°C". */
+declare function useTemperatureUnit(): Accessor<string>;
+/** Reactive UI locale (BCP 47 tag) from HA config. Defaults to "en". */
+declare function useLocale(): Accessor<string>;
+/** Reactive currency (ISO 4217) from HA config. Defaults to "USD". */
+declare function useCurrency(): Accessor<string>;
+/**
+ * Get all service call functions.
+ */
+declare function useService(): {
+  callService: typeof callService;
+  turnOn: typeof turnOn;
+  turnOff: typeof turnOff;
+  toggle: typeof toggle;
+};
+/** Get turnOn command function */
+declare function useTurnOn(): typeof turnOn;
+/** Get turnOff command function */
+declare function useTurnOff(): typeof turnOff;
+/** Get toggle command function */
+declare function useToggle(): typeof toggle;
+/**
+ * Get reactive list of all area views.
+ */
+declare function useAreas(): Accessor<AreaView[]>;
+/**
+ * Get a reactive AreaView for a specific area.
+ *
+ * Registers all entities in the area for live updates.
+ */
+declare function useArea(areaId: Accessor<string> | string): Accessor<AreaView | undefined>;
+/**
+ * Get reactive entity history data.
+ *
+ * History data is populated into the store via subscriptions;
+ * this hook simply reads it reactively.
+ */
+declare function useEntityHistory(entityId: Accessor<string> | string): Accessor<EntityHistoryData | undefined>;
+/**
+ * Get reactive long-term statistics for a statistic id.
+ *
+ * Fetches via `recorder/statistics_during_period` and re-fetches whenever the
+ * statistic id or options change. The returned Resource exposes `.loading`
+ * and `.error` alongside the value accessor.
+ */
+declare function useEntityStatistics(statisticId: Accessor<string> | string, options: Accessor<StatisticsQueryOptions> | StatisticsQueryOptions): Resource<StatisticValue[]>;
+/**
+ * Get reactive camera stream data.
+ */
+declare function useCamera(entityId: Accessor<string> | string): {
+  stream: Accessor<CameraStreamData | null>;
+  refresh: () => void;
+};
+/**
+ * Live calendar events for one calendar entity.
+ *
+ * Tracks the entity on mount (opening or joining the shared
+ * `calendar/event/subscribe`) and untracks on cleanup; HA pushes the initial
+ * snapshot and every later change, so the accessor is reactive with no
+ * polling. `undefined` until the subscription is established.
+ */
+declare function useCalendarEvents(entityId: Accessor<string> | string, options?: CalendarWindowOptions): Accessor<CalendarEventsData | undefined>;
+/**
+ * Get reactive weather forecast data.
+ */
+declare function useForecast(entityId: Accessor<string> | string): Accessor<WeatherForecastsData | undefined>;
+/**
+ * Escape hatch for direct store access with a selector.
  *
- * @packageDocumentation
+ * Use when no specific hook exists for your data need.
  */
-export { useArea, useAreas, useCalendarEvents, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityState, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOff, useTurnOn, useUnitSystem, } from "./hooks";
-export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, } from "./indices";
+declare function useStore<T>(selector: (s: GlassHomeState) => T): Accessor<T>;
+//#endregion
+//#region src/solid/indices.d.ts
+/** Entity IDs grouped by domain (e.g., "light" -> ["light.living_room", ...]) */
+declare const byDomain: Accessor<Record<string, string[]>>;
+/** Entity IDs grouped by area (via entity registry area_id) */
+declare const byArea: Accessor<Record<string, string[]>>;
+/** Entity IDs grouped by device (via entity registry device_id) */
+declare const byDevice: Accessor<Record<string, string[]>>;
+/** Entity IDs grouped by floor (device -> area -> floor chain) */
+declare const byFloor: Accessor<Record<string, string[]>>;
+/** Entity IDs grouped by label */
+declare const byLabel: Accessor<Record<string, string[]>>;
+/** All entity IDs currently in the store */
+declare const allEntityIds: Accessor<string[]>;
+//#endregion
+export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, useArea, useAreas, useCalendarEvents, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityState, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOff, useTurnOn, useUnitSystem };

package/dist/solid/index.js

@@ -1,8 +1,19 @@
-import { buildAreaView, callService, entityViewEquals, extractDomain, fetchStatisticsDuringPeriod, getAreaViews, getEntityView, isDemoMode, privilegedConn, registerEntity, state, toggle, trackCalendarEvents, turnOff, turnOn } from "../statistics-CtRfIF6D.js";
+import { A as extractDomain, B as state, I as trackCalendarEvents, L as privilegedConn, M as registerEntity, _ as turnOff, c as entityViewEquals, g as toggle, m as callService, o as getAreaViews, r as buildAreaView, t as fetchStatisticsDuringPeriod, u as getEntityView, v as turnOn, x as isDemoMode } from "../statistics-DyCCTwv2.js";
 import { createEffect, createMemo, createResource, onCleanup } from "solid-js";
-
 //#region src/solid/hooks.ts
 /**
+* SolidJS Hooks for Sync-Layer
+*
+* Thin createMemo wrappers over the native SolidJS store.
+* Since the store IS SolidJS (Plan 01 replaced Zustand with createStore),
+* no subscription bridge is needed -- SolidJS auto-tracks fine-grained
+* reactivity through the store proxy.
+*
+* Every hook is just `createMemo(() => state.something)`.
+*
+* @packageDocumentation
+*/
+/**
 * Get a reactive EntityView for an entity ID.
 *
 * Registers the entity for live updates via the subscription manager.
@@ -29,8 +40,7 @@ function useEntity(entityId) {
 */
 function useEntities(entityIds) {
 	createEffect(() => {
-		const ids = entityIds();
-		const unregisters = ids.map((id) => registerEntity(id));
+		const unregisters = entityIds().map((id) => registerEntity(id));
 		onCleanup(() => {
 			for (const unreg of unregisters) unreg();
 		});
@@ -62,11 +72,9 @@ function useEntityState(entityId) {
 * Get reactive connection status.
 */
 function useConnection() {
-	const status = createMemo(() => state.connectionState);
-	const isConnected = createMemo(() => state.connectionState === "connected");
 	return {
-		status,
-		isConnected
+		status: createMemo(() => state.connectionState),
+		isConnected: createMemo(() => state.connectionState === "connected")
 	};
 }
 /** Reactive Home Assistant core config (null until loaded). */
@@ -140,7 +148,7 @@ function useArea(areaId) {
 		try {
 			return buildAreaView(id);
 		} catch {
-			return void 0;
+			return;
 		}
 	});
 	createEffect(() => {
@@ -168,7 +176,7 @@ function useEntityHistory(entityId) {
 * sends a message, so this only satisfies the signature.
 */
 const DEMO_STATS_CONNECTION = { sendMessagePromise() {
-	return Promise.reject(new Error("demo mode: no connection"));
+	return Promise.reject(/* @__PURE__ */ new Error("demo mode: no connection"));
 } };
 /**
 * Get reactive long-term statistics for a statistic id.
@@ -187,8 +195,7 @@ function useEntityStatistics(statisticId, options) {
 		if (!id) return [];
 		const conn = privilegedConn();
 		if (!conn && !isDemoMode()) return [];
-		const result = await fetchStatisticsDuringPeriod(conn ?? DEMO_STATS_CONNECTION, [id], opts);
-		return result[id] ?? [];
+		return (await fetchStatisticsDuringPeriod(conn ?? DEMO_STATS_CONNECTION, [id], opts))[id] ?? [];
 	});
 	return data;
 }
@@ -235,7 +242,6 @@ function useForecast(entityId) {
 function useStore(selector) {
 	return createMemo(() => selector(state));
 }
-
 //#endregion
 //#region src/solid/indices.ts
 function groupBy(items, keyFn) {
@@ -272,6 +278,5 @@ const byLabel = () => {
 };
 /** All entity IDs currently in the store */
 const allEntityIds = () => Object.keys(state.entities);
-
 //#endregion
-export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, useArea, useAreas, useCalendarEvents, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityState, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOff, useTurnOn, useUnitSystem };
+export { allEntityIds, byArea, byDevice, byDomain, byFloor, byLabel, useArea, useAreas, useCalendarEvents, useCamera, useConnection, useCurrency, useEntities, useEntity, useEntityHistory, useEntityState, useEntityStatistics, useForecast, useHassConfig, useLocale, useService, useStore, useTemperatureUnit, useToggle, useTurnOff, useTurnOn, useUnitSystem };