@nice2dev/ui-buildings 1.0.10

package/dist/index.d.ts

@@ -0,0 +1,1191 @@
+import { AlignmentGuide } from '@nice2dev/spatial-core';
+import { AngleUnit } from '@nice2dev/spatial-core';
+import { AreaUnit } from '@nice2dev/spatial-core';
+import { BoundingBox } from '@nice2dev/spatial-core';
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { FloorPlanDocument } from '@nice2dev/spatial-core';
+import { LengthUnit } from '@nice2dev/spatial-core';
+import { Point2D as Point2D_2 } from '@nice2dev/spatial-core';
+import { SnapMode } from '@nice2dev/spatial-core';
+import { SpatialObject } from '@nice2dev/spatial-core';
+import { TracelessStorageProps } from '@nice2dev/ui';
+import { UnitSystem } from '@nice2dev/spatial-core';
+
+declare interface AccessLogEntry {
+    id: string;
+    timestamp: string;
+    user?: string;
+    method: 'pin' | 'key' | 'app' | 'fingerprint' | 'rfid' | 'auto';
+    success: boolean;
+}
+
+declare type ActionType = 'device_control' | 'scene_activate' | 'notification' | 'delay' | 'webhook' | 'http_request' | 'building_mode' | 'script';
+
+export declare interface AlarmState {
+    armed: 'disarmed' | 'armed_home' | 'armed_away' | 'armed_night' | 'armed_vacation';
+    triggered: boolean;
+    triggeredZones?: string[];
+    code?: string;
+}
+
+declare type AlertSeverity = 'info' | 'warning' | 'critical' | 'resolved';
+
+export declare type AutomationAction = DeviceControlAction | SceneActivateAction | NotificationAction | DelayAction | {
+    type: ActionType;
+    [key: string]: unknown;
+};
+
+export declare interface AutomationCondition {
+    operator?: ConditionOperator;
+    conditions?: AutomationCondition[];
+    deviceId?: BuildingId;
+    attribute?: string;
+    operator2?: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte';
+    value?: unknown;
+    timeAfter?: string;
+    timeBefore?: string;
+    days?: string[];
+    OccupancyMode?: string;
+}
+
+export declare type AutomationTrigger = TimeTrigger | SunTrigger | DeviceStateTrigger | SensorThresholdTrigger | GeofenceTrigger | {
+    type: TriggerType;
+    [key: string]: unknown;
+};
+
+export declare interface BlindState {
+    open: boolean;
+    position: number;
+    tilt?: number;
+    moving?: 'up' | 'down' | null;
+}
+
+export declare type BmsProtocol = 'bacnet' | 'dali' | 'lonworks' | 'opc-ua' | 'knx' | 'modbus';
+
+export declare interface Building {
+    id: BuildingId;
+    name: string;
+    address?: string;
+    timezone?: string;
+    latitude?: number;
+    longitude?: number;
+    floors: BuildingFloor[];
+    rooms: BuildingZone[];
+    devices: BuildingDevice[];
+    scenes: BuildingScene[];
+    automations: BuildingAutomation[];
+    floorPlan?: FloorPlanFloor[];
+}
+
+/** Root aggregated building model used as top-level prop for most components */
+export declare interface Building {
+    id: BuildingId;
+    name: string;
+    type: BuildingType;
+    address?: string;
+    timezone?: string;
+    latitude?: number;
+    longitude?: number;
+    floors: BuildingFloor[];
+    zones: BuildingZone[];
+    devices: BuildingDevice[];
+    scenes: BuildingScene[];
+    automations: BuildingAutomation[];
+    floorPlan?: FloorPlanFloor[];
+}
+
+declare interface BuildingAlert {
+    id: BuildingId;
+    deviceId?: BuildingId;
+    zoneId?: BuildingId;
+    type: string;
+    severity: AlertSeverity;
+    title: string;
+    message: string;
+    timestamp: string;
+    acknowledged: boolean;
+    acknowledgedAt?: string;
+    resolvedAt?: string;
+}
+
+export declare interface BuildingAutomation {
+    id: BuildingId;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    triggers: AutomationTrigger[];
+    /** Optional list of conditions that must all match. */
+    conditions?: AutomationCondition[];
+    actions: AutomationAction[];
+    lastTriggered?: string;
+    runCount?: number;
+    category?: string;
+    icon?: string;
+}
+
+export declare interface BuildingDevice {
+    id: BuildingId;
+    name: string;
+    type: DeviceType;
+    zoneId?: BuildingId;
+    area?: string;
+    protocol: DeviceProtocol;
+    model?: string;
+    manufacturer?: string;
+    firmwareVersion?: string;
+    status: DeviceStatus;
+    state: DeviceState;
+    capabilities: DeviceCapability[];
+    /** Position on floor plan (relative to room bounds, 0-1) */
+    floorPlanPosition?: Point2D;
+    icon?: string;
+    color?: string;
+    tags?: string[];
+    favorite?: boolean;
+    hidden?: boolean;
+    lastSeen?: string;
+    metadata?: Record<string, unknown>;
+}
+
+export declare interface BuildingFloor {
+    id: BuildingId;
+    name: string;
+    level: number;
+    icon?: string;
+    /** Zones contained on this floor. */
+    zones?: FloorPlanZone[];
+}
+
+export declare type BuildingId = string;
+
+export declare interface BuildingScene {
+    id: BuildingId;
+    name: string;
+    icon?: string;
+    color?: string;
+    description?: string;
+    /** Per-device target states applied when the scene activates. */
+    deviceTargets: SceneDeviceTarget[];
+    /** @deprecated alias for {@link deviceTargets}. */
+    devices?: SceneDeviceTarget[];
+    isActive?: boolean;
+    favorite?: boolean;
+    category?: string;
+    activatedAt?: string;
+}
+
+export declare interface BuildingState {
+    buildingId: BuildingId;
+    mode: OccupancyMode;
+    occupants?: string[];
+    lastModeChange?: string;
+    weather?: {
+        temp: number;
+        description: string;
+        icon: string;
+        humidity: number;
+        windSpeed: number;
+    };
+    energy?: EnergyStats;
+    /** Per-zone live occupancy snapshot. */
+    occupancy?: Record<string, {
+        occupancy?: number;
+        mode?: OccupancyMode;
+    } | undefined>;
+    activeAlerts: BuildingAlert[];
+    activeScenes: BuildingId[];
+}
+
+export declare type BuildingType = 'residential' | 'office' | 'retail' | 'industrial' | 'hotel' | 'hospital' | 'school' | 'warehouse' | 'mixed' | 'other';
+
+export declare interface BuildingZone {
+    id: BuildingId;
+    name: string;
+    type: ZoneType;
+    floorId?: BuildingId;
+    icon?: string;
+    color?: string;
+    area?: number;
+    order?: number;
+    /** Live climate / occupancy snapshot. */
+    temperature?: number;
+    humidity?: number;
+    co2?: number;
+    occupancy?: number;
+    /** Optional list of device IDs attached to this zone. */
+    deviceIds?: BuildingId[];
+}
+
+export declare interface CameraState {
+    streaming: boolean;
+    recording: boolean;
+    motionDetected: boolean;
+    streamUrl?: string;
+    snapshotUrl?: string;
+    lastMotion?: string;
+}
+
+export declare interface ClimateState extends ThermostatState {
+    swingMode?: 'off' | 'vertical' | 'horizontal' | 'both';
+    presetMode?: 'eco' | 'comfort' | 'boost' | 'sleep' | 'away';
+}
+
+declare type ConditionOperator = 'and' | 'or';
+
+declare interface DelayAction {
+    type: 'delay';
+    seconds: number;
+}
+
+/** Capability identifier. Either a free-form string (e.g. `'dimming'`) or a structured descriptor. */
+declare type DeviceCapability = string | {
+    name: string;
+    type: 'onoff' | 'brightness' | 'color_temp' | 'color_rgb' | 'temperature_set' | 'mode' | 'position' | 'tilt' | 'volume' | 'media_controls' | 'lock_unlock' | 'alarm_arm' | 'energy_read' | 'text' | 'button' | 'sensor_read' | 'camera_stream';
+    readOnly?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: string[];
+};
+
+declare interface DeviceControlAction {
+    type: 'device_control';
+    deviceId: BuildingId;
+    state: Partial<DeviceState>;
+    transitionMs?: number;
+}
+
+export declare type DeviceProtocol = 'zigbee' | 'z-wave' | 'wifi' | 'bluetooth' | 'matter' | 'thread' | 'knx' | 'modbus' | 'cloud' | 'local_api' | 'other';
+
+declare type DeviceState = LightState | ThermostatState | LockState | BlindState | SwitchState | CameraState | AlarmState | SensorState | ClimateState | MediaPlayerState | EnergyMeterState | Record<string, unknown>;
+
+declare interface DeviceStateTrigger {
+    type: 'device_state';
+    deviceId: BuildingId;
+    attribute: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'changed';
+    value?: unknown;
+}
+
+export declare type DeviceStatus = 'online' | 'offline' | 'unavailable' | 'updating' | 'error';
+
+export declare type DeviceType = 'light' | 'dimmer' | 'rgb_light' | 'led_strip' | 'thermostat' | 'heater' | 'air_conditioner' | 'fan' | 'heat_pump' | 'lock' | 'door' | 'window' | 'blind' | 'shutter' | 'garage' | 'gate' | 'switch' | 'outlet' | 'smart_plug' | 'power_strip' | 'camera' | 'doorbell' | 'alarm' | 'siren' | 'motion_sensor' | 'door_sensor' | 'window_sensor' | 'smoke_detector' | 'co_detector' | 'water_leak' | 'gas_detector' | 'temperature_sensor' | 'humidity_sensor' | 'air_quality' | 'light_sensor' | 'presence_sensor' | 'speaker' | 'tv' | 'media_player' | 'vacuum' | 'washing_machine' | 'dishwasher' | 'oven' | 'fridge' | 'irrigation' | 'pool' | 'ev_charger' | 'solar_panel' | 'battery' | 'energy_meter' | 'hub' | 'router' | 'other';
+
+declare type DisplayDensity = 'compact' | 'comfortable' | 'spacious';
+
+export declare interface EnergyByZone {
+    zoneId: BuildingId;
+    zoneName: string;
+    kwh: number;
+    percentOfTotal: number;
+}
+
+export declare interface EnergyMeterState {
+    power: number;
+    voltage: number;
+    current: number;
+    frequency?: number;
+    energyTotal: number;
+    energyToday: number;
+    energyMonth: number;
+    tariff?: number;
+}
+
+declare interface EnergyStats {
+    /** kWh consumed today */
+    today: number;
+    /** kWh consumed this week */
+    week: number;
+    /** kWh consumed this month */
+    month: number;
+    /** Current power draw in Watts */
+    currentPower: number;
+    /** Alias for {@link currentPower} (Watts). */
+    currentPowerW?: number;
+    /** Alias for {@link today} (kWh). */
+    todayKwh?: number;
+    /** Cost today in home currency */
+    costToday?: number;
+    /** Solar production today (kWh) */
+    solarToday?: number;
+    /** Battery level if home battery present (0-100) */
+    batteryLevel?: number;
+    /** Hourly data for today [0-23] */
+    hourlyToday?: number[];
+    /** Daily data for last 30 days */
+    dailyMonth?: number[];
+}
+
+export declare interface FloorPlanEditorState {
+    floorId: BuildingId;
+    tool: FloorPlanTool;
+    selectedElements: FloorPlanSelection[];
+    zoom: number;
+    panOffset: Point2D;
+    drawingPolygon: Point2D[] | null;
+    hoveredElement: FloorPlanSelection | null;
+    showGrid: boolean;
+    showDimensions: boolean;
+    showDeviceLabels: boolean;
+    snapToGrid: boolean;
+    gridSize: number;
+}
+
+declare type FloorPlanElementType = 'room' | 'zone' | 'device' | 'door' | 'window_fp' | 'wall' | 'stair' | 'annotation';
+
+export declare interface FloorPlanFloor {
+    id: BuildingId;
+    name: string;
+    level: number;
+    backgroundImage?: string;
+    width: number;
+    height: number;
+    scale?: number;
+    /** Floor zones (preferred). */
+    zones: FloorPlanZone[];
+    /** @deprecated alias for {@link zones}. */
+    rooms?: FloorPlanZone[];
+}
+
+export declare interface FloorPlanSelection {
+    type: FloorPlanElementType;
+    id: BuildingId;
+}
+
+export declare type FloorPlanTool = 'select' | 'draw_room' | 'draw_zone' | 'draw_wall' | 'place_device' | 'place_door' | 'place_window' | 'annotate' | 'erase' | 'measure' | 'pan';
+
+export declare interface FloorPlanZone {
+    id: BuildingId;
+    name: string;
+    type: ZoneType;
+    floorId: BuildingId;
+    /** Polygon vertices relative to floor plan canvas (px) */
+    polygon: Point2D[];
+    /** Bounding rect (computed from polygon) */
+    bounds?: Rect2D;
+    color?: string;
+    opacity?: number;
+    /** Climate sensor reading for this room */
+    temperature?: number;
+    humidity?: number;
+    /** CO₂ ppm reading. */
+    co2?: number;
+    /** Number of detected occupants. */
+    occupancy?: number;
+    area?: number;
+    /** Optional list of device IDs attached to this zone. */
+    deviceIds?: BuildingId[];
+}
+
+declare interface FloorTransition {
+    fromFloorId: string;
+    toFloorId: string;
+    type: 'elevator' | 'stairs' | 'escalator';
+    position: Point2D_2;
+}
+
+declare interface GeofenceTrigger {
+    type: 'geofence';
+    userId?: string;
+    zone: 'home' | 'away';
+    radius?: number;
+}
+
+/**
+ * History action for undo/redo
+ */
+declare interface HistoryAction {
+    id: string;
+    timestamp: number;
+    type: 'create' | 'update' | 'delete' | 'move' | 'group' | 'ungroup';
+    objectIds: string[];
+    /** State before action (for undo) */
+    before: unknown;
+    /** State after action (for redo) */
+    after: unknown;
+}
+
+/** @deprecated Use OccupancyMode instead */
+export declare type HomeMode = OccupancyMode;
+
+export declare const LayerPanel: default_2.FC<LayerPanelProps>;
+
+declare interface LayerPanelProps {
+    /** Layer states */
+    layers: LayerState[];
+    /** Callback when visibility is toggled */
+    onVisibilityToggle: (layerType: LayerType) => void;
+    /** Callback when lock is toggled */
+    onLockToggle: (layerType: LayerType) => void;
+    /** Callback when opacity changes */
+    onOpacityChange: (layerType: LayerType, opacity: number) => void;
+    /** CSS class name */
+    className?: string;
+}
+
+/**
+ * Layer visibility and editing state
+ */
+export declare interface LayerState {
+    type: LayerType;
+    visible: boolean;
+    locked: boolean;
+    opacity: number;
+    zIndex: number;
+}
+
+/**
+ * Layer types available in the editor
+ */
+export declare type LayerType = 'floor-plan' | 'zones' | 'devices' | 'furniture' | 'network' | 'infrastructure' | 'annotations' | 'dimensions' | 'grid' | 'background' | 'game-objects' | 'collision';
+
+export declare interface LightState {
+    on: boolean;
+    brightness?: number;
+    colorTemperature?: number;
+    /** Backwards-compatible alias for {@link colorTemperature}. */
+    colorTemp?: number;
+    /** RGB tuple [r,g,b] each 0-255. */
+    rgbColor?: [number, number, number];
+    /** Backwards-compatible alias for {@link rgbColor}. */
+    color?: RgbColor;
+    effect?: string;
+}
+
+export declare interface LockState {
+    locked: boolean;
+    jammed?: boolean;
+    lastChanged?: string;
+    lastChangedBy?: string;
+    doorOpen?: boolean;
+    accessLog?: AccessLogEntry[];
+}
+
+declare interface MeasurementPoint {
+    position: Point2D_2;
+    snapped: boolean;
+}
+
+declare interface MeasurementResult {
+    type: 'distance' | 'angle' | 'area' | 'perimeter';
+    value: number;
+    formatted: string;
+    points: Point2D_2[];
+}
+
+export declare interface MediaPlayerState {
+    playing: boolean;
+    volume: number;
+    muted: boolean;
+    source?: string;
+    title?: string;
+    artist?: string;
+    albumArt?: string;
+    position?: number;
+    duration?: number;
+}
+
+export declare const Minimap: default_2.FC<MinimapProps>;
+
+declare interface MinimapProps {
+    /** Document to display */
+    document: FloorPlanDocument;
+    /** Active floor ID */
+    activeFloorId: string | null;
+    /** Current viewport state */
+    viewport: ViewportState;
+    /** Callback when viewport changes (pan) */
+    onViewportChange: (viewport: Partial<ViewportState>) => void;
+    /** Minimap size */
+    size?: number;
+    /** CSS class name */
+    className?: string;
+}
+
+declare interface NavigationInstruction {
+    type: 'straight' | 'left' | 'right' | 'elevator' | 'stairs' | 'arrive';
+    distance?: number;
+    direction?: string;
+    landmark?: string;
+}
+
+declare interface NavigationRoute {
+    id: string;
+    startPoint: Point2D_2;
+    endPoint: Point2D_2;
+    path: Point2D_2[];
+    floorTransitions: FloorTransition[];
+    totalDistance: number;
+    estimatedTime: number;
+    instructions: NavigationInstruction[];
+}
+
+export declare const NiceAutomationEditor: default_2.FC<NiceAutomationEditorProps>;
+
+export declare interface NiceAutomationEditorProps {
+    automations: BuildingAutomation[];
+    devices?: BuildingDevice[];
+    zones?: BuildingZone[];
+    scenes?: BuildingScene[];
+    onAutomationsChange?: (automations: BuildingAutomation[]) => void;
+    onSave?: (automation: BuildingAutomation) => Promise<void> | void;
+    onDelete?: (id: BuildingId) => Promise<void> | void;
+    onToggle?: (id: BuildingId, enabled: boolean) => Promise<void> | void;
+    readOnly?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    theme?: 'light' | 'dark';
+}
+
+export declare const NiceBuildingDashboard: default_2.FC<NiceBuildingDashboardProps>;
+
+export declare interface NiceBuildingDashboardProps {
+    /** Building model (preferred). */
+    building: Building;
+    /** @deprecated alias for {@link building}. */
+    home?: Building;
+    state?: BuildingState;
+    onDeviceControl?: (deviceId: BuildingId, state: Partial<DeviceState>) => Promise<void> | void;
+    onSceneActivate?: (sceneId: BuildingId) => Promise<void> | void;
+    onModeChange?: (mode: OccupancyMode) => void;
+    /** @deprecated use {@link onModeChange}. */
+    onHomeModeChange?: (mode: OccupancyMode) => void;
+    onZoneClick?: (zoneId: BuildingId) => void;
+    /** Optional weather widget data. */
+    weather?: {
+        temperature?: number;
+        description?: string;
+    };
+    showEnergy?: boolean;
+    showMap?: boolean;
+    showWeather?: boolean;
+    density?: DisplayDensity;
+    favoriteDeviceIds?: BuildingId[];
+    className?: string;
+    style?: CSSProperties;
+    theme?: 'light' | 'dark';
+}
+
+export declare const NiceDeviceControl: default_2.FC<NiceDeviceControlProps>;
+
+export declare interface NiceDeviceControlProps {
+    device: BuildingDevice;
+    /** Device control callback. Receives device id and partial state patch. */
+    onControl?: (deviceId: BuildingId, state: Partial<DeviceState> & {
+        command?: string;
+    }) => Promise<void> | void;
+    compact?: boolean;
+    showLabel?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    theme?: 'light' | 'dark';
+}
+
+export declare const NiceFloorPlanEditor: default_2.FC<NiceFloorPlanEditorProps>;
+
+export declare interface NiceFloorPlanEditorProps {
+    floors: FloorPlanFloor[];
+    devices?: BuildingDevice[];
+    onFloorChange?: (floors: FloorPlanFloor[]) => void;
+    onDeviceMove?: (deviceId: BuildingId, floorId: BuildingId, roomId: BuildingId | null, position: Point2D) => void;
+    readOnly?: boolean;
+    initialFloorId?: BuildingId;
+    showDevices?: boolean;
+    showDimensions?: boolean;
+    showGrid?: boolean;
+    /** Show occupancy heatmap overlay. */
+    showOccupancy?: boolean;
+    /** Show climate (temperature/humidity) overlay. */
+    showClimate?: boolean;
+    devicePalette?: BuildingDevice[];
+    className?: string;
+    style?: CSSProperties;
+    theme?: 'light' | 'dark';
+}
+
+export declare const NiceLightControl: default_2.FC<NiceLightControlProps>;
+
+export declare interface NiceLightControlProps {
+    device: BuildingDevice;
+    state?: LightState;
+    onControl?: (deviceId: BuildingId, state: Partial<LightState>) => Promise<void> | void;
+    showColor?: boolean;
+    showColorTemp?: boolean;
+    showEffects?: boolean;
+    compact?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    theme?: 'light' | 'dark';
+}
+
+export declare const NiceSceneEditor: default_2.FC<NiceSceneEditorProps>;
+
+export declare interface NiceSceneEditorProps {
+    scenes: BuildingScene[];
+    devices?: BuildingDevice[];
+    zones?: BuildingZone[];
+    /** Currently active scene ids (highlighted). */
+    activeSceneIds?: BuildingId[];
+    onScenesChange?: (scenes: BuildingScene[]) => void;
+    onSave?: (scene: BuildingScene) => Promise<void> | void;
+    onDelete?: (id: BuildingId) => Promise<void> | void;
+    onActivate?: (id: BuildingId) => Promise<void> | void;
+    readOnly?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    theme?: 'light' | 'dark';
+}
+
+export declare const NiceSpatialEditor: default_2.FC<NiceSpatialEditorProps>;
+
+/**
+ * NiceSpatialEditor component props
+ */
+export declare interface NiceSpatialEditorProps extends TracelessStorageProps {
+    /** Initial document to edit */
+    document?: FloorPlanDocument;
+    /** Alias for {@link document} — initial document loaded into the editor. */
+    initialDocument?: FloorPlanDocument;
+    /** Default editor mode */
+    defaultMode?: SpatialEditorMode;
+    /** Available modes (defaults to all) */
+    availableModes?: SpatialEditorMode[];
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Theme */
+    theme?: 'light' | 'dark' | 'auto';
+    /** Locale for labels */
+    locale?: 'en' | 'pl' | 'de' | 'es' | 'fr';
+    /** Initial grid size */
+    gridSize?: number;
+    /** Enable snap by default */
+    snapEnabled?: boolean;
+    /** Show object library sidebar */
+    showObjectLibrary?: boolean;
+    /** Show layer panel */
+    showLayerPanel?: boolean;
+    /** Show properties panel */
+    showPropertiesPanel?: boolean;
+    /** Show minimap */
+    showMinimap?: boolean;
+    /** Custom object library items */
+    customObjects?: SpatialObject[];
+    /** Callback when document changes */
+    onDocumentChange?: (document: FloorPlanDocument) => void;
+    /** Callback when selection changes */
+    onSelectionChange?: (selection: SpatialSelection) => void;
+    /** Callback when mode changes */
+    onModeChange?: (mode: SpatialEditorMode) => void;
+    /** Export callback */
+    onExport?: (format: 'nsp' | 'svg' | 'png' | 'pdf' | 'dxf', data: Blob | string) => void;
+    /** Import callback */
+    onImport?: (document: FloorPlanDocument) => void;
+    /** CSS class name */
+    className?: string;
+    /** Inline styles */
+    style?: React.CSSProperties;
+    /** Persist editor preferences (zoom, pan, grid, layer visibility) */
+    persistPreferences?: boolean;
+}
+
+export declare const NiceSpatialViewer: default_2.FC<NiceSpatialViewerProps>;
+
+declare interface NiceSpatialViewerProps {
+    /** Floor plan document to display. */
+    document: FloorPlanDocument;
+    /** Initial floor ID to show. */
+    initialFloorId?: string;
+    /** Show navigation panel. */
+    showNavigation?: boolean;
+    /** Show mini-map overlay. */
+    showMinimap?: boolean;
+    /** Show floor selector. */
+    showFloorSelector?: boolean;
+    /** Show search bar. */
+    showSearch?: boolean;
+    /** Show layers panel button. */
+    showLayersPanel?: boolean;
+    /** Alias of {@link showLayersPanel}. */
+    showLayers?: boolean;
+    /** Show legend panel button. */
+    showLegend?: boolean;
+    /** Enable route planning. */
+    enableRoutePlanning?: boolean;
+    /** Reference points for navigation (entrances, elevators). */
+    referencePoints?: ReferencePoint[];
+    /** Called when user clicks on an object. */
+    onObjectClick?: (object: SpatialObject) => void;
+    /** Called when navigation route is calculated. */
+    onRouteCalculated?: (route: NavigationRoute | null) => void;
+    /** Current user location (for indoor positioning). */
+    currentLocation?: Point2D_2;
+    /** Theme: light or dark. */
+    theme?: 'light' | 'dark';
+    /** Custom class name. */
+    className?: string;
+    /**
+     * Enable virtual rendering for large floor plans (1000+ objects).
+     * Uses viewport culling and QuadTree spatial indexing.
+     */
+    virtualRendering?: boolean;
+    /**
+     * Object count threshold to auto-enable virtual rendering.
+     * Default: 200.
+     */
+    virtualRenderingThreshold?: number;
+    /** Debug mode: show visible object count and stats. */
+    debugVirtualRendering?: boolean;
+}
+
+export declare const NiceThermostatControl: default_2.FC<NiceThermostatControlProps>;
+
+export declare interface NiceThermostatControlProps {
+    device: BuildingDevice;
+    state?: ThermostatState;
+    onControl?: (deviceId: BuildingId, state: Partial<ThermostatState>) => Promise<void> | void;
+    showSchedule?: boolean;
+    showHumidity?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    unit?: 'C' | 'F';
+    compact?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    theme?: 'light' | 'dark';
+}
+
+export declare const NiceZoneCard: default_2.FC<NiceZoneCardProps>;
+
+export declare interface NiceZoneCardProps {
+    /** Zone metadata (preferred). */
+    zone: FloorPlanZone | BuildingZone;
+    /** @deprecated alias for {@link zone}. */
+    room?: BuildingZone;
+    devices?: BuildingDevice[];
+    temperature?: number;
+    humidity?: number;
+    expanded?: boolean;
+    onExpand?: () => void;
+    onDeviceControl?: (deviceId: BuildingId, state: Partial<DeviceState>) => Promise<void> | void;
+    /** @deprecated use {@link onDeviceControl}. */
+    onControl?: (deviceId: BuildingId, state: Partial<DeviceState>) => Promise<void> | void;
+    onClick?: () => void;
+    onRoomClick?: (roomId: BuildingId) => void;
+    density?: DisplayDensity;
+    className?: string;
+    style?: CSSProperties;
+    theme?: 'light' | 'dark';
+}
+
+declare interface NotificationAction {
+    type: 'notification';
+    title: string;
+    message: string;
+    channel?: 'push' | 'email' | 'sms' | 'in_app';
+    priority?: 'low' | 'normal' | 'high' | 'critical';
+}
+
+export declare type NotificationChannel = 'push' | 'email' | 'sms' | 'in_app' | 'teams' | 'slack' | 'webhook';
+
+export declare const ObjectLibrary: default_2.FC<ObjectLibraryProps>;
+
+declare interface ObjectLibraryProps {
+    /** Current editor mode */
+    mode: SpatialEditorMode;
+    /** Callback when an object is selected for placement */
+    onObjectSelect: (object: {
+        id: string;
+        name: string;
+        category: string;
+        icon?: string;
+    }) => void;
+    /** Custom objects to include */
+    customObjects?: Array<{
+        id: string;
+        name: string;
+        category: string;
+        icon?: string;
+    }>;
+    /** CSS class name */
+    className?: string;
+}
+
+export declare type OccupancyMode = 'home' | 'away' | 'night' | 'vacation' | 'guest' | 'party' | 'occupied' | 'closed' | 'weekend' | 'event' | 'emergency' | 'maintenance';
+
+/** Extended occupancy sensor state (zone-level device) */
+export declare interface OccupancySensorState {
+    occupied: boolean;
+    count?: number;
+    confidence?: number;
+    lastMotion?: string;
+}
+
+export declare interface OccupancyStats {
+    totalOccupied: number;
+    totalZones: number;
+    byZone: ZoneOccupancy[];
+    peakToday?: number;
+    peakTime?: string;
+    hourlyToday?: number[];
+}
+
+export declare interface Point2D {
+    x: number;
+    y: number;
+}
+
+export declare const PropertiesPanel: default_2.FC<PropertiesPanelProps>;
+
+declare interface PropertiesPanelProps {
+    /** Current selection */
+    selection: SpatialSelection;
+    /** Document for lookups */
+    document: FloorPlanDocument;
+    /** Callback when a property changes */
+    onPropertyChange: (objectId: string, key: string, value: unknown) => void;
+    /** CSS class name */
+    className?: string;
+}
+
+declare interface Rect2D {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+declare interface ReferencePoint {
+    id: string;
+    name: string;
+    type: 'entrance' | 'elevator' | 'stairs' | 'exit' | 'poi' | 'parking';
+    position: Point2D_2;
+    floorId: string;
+    icon?: string;
+    description?: string;
+}
+
+declare interface RgbColor {
+    r: number;
+    g: number;
+    b: number;
+}
+
+declare interface SceneActivateAction {
+    type: 'scene_activate';
+    sceneId: BuildingId;
+}
+
+export declare interface SceneDeviceTarget {
+    deviceId: BuildingId;
+    state: Partial<DeviceState>;
+    transitionMs?: number;
+}
+
+declare type SensorReadingType = 'temperature' | 'humidity' | 'pressure' | 'co2' | 'voc' | 'pm25' | 'pm10' | 'noise' | 'lux' | 'uv' | 'motion' | 'power' | 'energy' | 'water_flow' | 'gas' | 'radon';
+
+export declare interface SensorState {
+    value: number;
+    unit: string;
+    battery?: number;
+    tampered?: boolean;
+}
+
+declare interface SensorThresholdTrigger {
+    type: 'sensor_threshold';
+    deviceId: BuildingId;
+    sensorType: SensorReadingType;
+    operator: 'above' | 'below' | 'eq';
+    threshold: number;
+    unit: string;
+    hysteresis?: number;
+}
+
+/** @deprecated Use Building instead */
+export declare type SmartHome = Building;
+
+/** @deprecated Use BuildingDevice instead */
+export declare type SmartHomeDevice = BuildingDevice;
+
+/**
+ * Editor modes — each mode provides different tools and UI
+ */
+export declare type SpatialEditorMode = 'floor-plan' | 'network-topology' | 'infrastructure' | 'cad' | 'interior' | 'game-scene';
+
+/**
+ * Complete editor state
+ */
+export declare interface SpatialEditorState {
+    /** Current editor mode */
+    mode: SpatialEditorMode;
+    /** Active tool */
+    tool: SpatialTool;
+    /** Document being edited */
+    document: FloorPlanDocument | null;
+    /** Current floor ID */
+    activeFloorId: string | null;
+    /** Layer states */
+    layers: LayerState[];
+    /** Current selection */
+    selection: SpatialSelection;
+    /** Viewport state */
+    viewport: ViewportState;
+    /** Drawing state (when using draw tools) */
+    drawing: {
+        active: boolean;
+        points: Point2D_2[];
+        preview: Point2D_2 | null;
+    };
+    /** History for undo/redo */
+    history: {
+        past: HistoryAction[];
+        future: HistoryAction[];
+    };
+    /** Alignment guides (for snap) */
+    guides: AlignmentGuide[];
+    /** Currently dragged object (drag & drop) */
+    dragging: {
+        objectType: string | null;
+        objectData: unknown;
+        position: Point2D_2 | null;
+    } | null;
+    /** Connection drawing state (for connect tool) */
+    connecting: {
+        active: boolean;
+        sourceId: string | null;
+        sourcePort?: string;
+        sourcePosition: Point2D_2 | null;
+        previewPosition: Point2D_2 | null;
+    };
+    /** Clipboard */
+    clipboard: SpatialObject[];
+    /** UI state */
+    ui: {
+        showObjectLibrary: boolean;
+        showLayerPanel: boolean;
+        showPropertiesPanel: boolean;
+        showMinimap: boolean;
+    };
+}
+
+/**
+ * Selection state
+ */
+export declare interface SpatialSelection {
+    /** Selected object IDs */
+    objectIds: string[];
+    /** Bounding box of selection */
+    bounds: BoundingBox | null;
+    /** Is selection locked */
+    locked: boolean;
+}
+
+/**
+ * Available spatial editing tools
+ */
+export declare type SpatialTool = 'select' | 'multi-select' | 'pan' | 'zoom' | 'draw-wall' | 'draw-zone' | 'draw-polyline' | 'draw-rectangle' | 'draw-circle' | 'draw-arc' | 'place-device' | 'place-furniture' | 'place-network' | 'place-infra' | 'place-door' | 'place-window' | 'place-stairs' | 'connect' | 'route-cable' | 'annotate' | 'dimension' | 'label' | 'measure-distance' | 'measure-angle' | 'measure-area' | 'move' | 'rotate' | 'scale' | 'erase' | 'copy' | 'paste';
+
+declare interface SunTrigger {
+    type: 'sunrise' | 'sunset';
+    offsetMinutes?: number;
+}
+
+export declare interface SwitchState {
+    on: boolean;
+    power?: number;
+    voltage?: number;
+    current?: number;
+    energyToday?: number;
+}
+
+export declare interface ThermostatState {
+    /** Current measured temperature in °C (or °F per `unit` prop). */
+    temperature: number;
+    /** Target setpoint in °C. */
+    targetTemperature: number;
+    /** @deprecated use {@link temperature} */
+    currentTemp?: number;
+    /** @deprecated use {@link targetTemperature} */
+    targetTemp?: number;
+    mode: 'heat' | 'cool' | 'auto' | 'off' | 'fan_only' | 'dry';
+    fanMode?: 'auto' | 'low' | 'medium' | 'high';
+    humidity?: number;
+    targetHumidity?: number;
+    hvacAction?: 'heating' | 'cooling' | 'idle' | 'fan' | 'drying' | 'off';
+    isScheduleActive?: boolean;
+}
+
+declare interface TimeTrigger {
+    type: 'time';
+    time: string;
+    days?: ('mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun')[];
+    repeat?: boolean;
+}
+
+declare type TriggerType = 'time' | 'sunrise' | 'sunset' | 'device_state' | 'sensor_threshold' | 'geofence' | 'webhook' | 'manual' | 'scene_activated' | 'building_mode';
+
+export declare function useMeasurement(options?: UseMeasurementOptions): UseMeasurementReturn;
+
+declare interface UseMeasurementOptions {
+    /** Unit system (metric or imperial) */
+    unitSystem?: UnitSystem;
+    /** Preferred length unit */
+    lengthUnit?: LengthUnit;
+    /** Preferred area unit */
+    areaUnit?: AreaUnit;
+    /** Preferred angle unit */
+    angleUnit?: AngleUnit;
+    /** Scale factor (pixels per meter) */
+    scale?: number;
+}
+
+declare interface UseMeasurementReturn {
+    /** Start a measurement */
+    startMeasurement: (type: 'distance' | 'angle' | 'area') => void;
+    /** Add a measurement point */
+    addPoint: (point: Point2D_2, snapped?: boolean) => void;
+    /** Clear current measurement */
+    clearMeasurement: () => void;
+    /** Finish measurement */
+    finishMeasurement: () => MeasurementResult | null;
+    /** Current measurement type */
+    measurementType: 'distance' | 'angle' | 'area' | null;
+    /** Current measurement points */
+    points: MeasurementPoint[];
+    /** Live distance (while measuring) */
+    liveDistance: string | null;
+    /** Live angle (while measuring) */
+    liveAngle: string | null;
+    /** Live area (while measuring) */
+    liveArea: string | null;
+    /** Calculate distance between two points */
+    getDistance: (p1: Point2D_2, p2: Point2D_2) => {
+        value: number;
+        formatted: string;
+    };
+    /** Calculate angle at three points */
+    getAngle: (p1: Point2D_2, vertex: Point2D_2, p2: Point2D_2) => {
+        value: number;
+        formatted: string;
+    };
+    /** Calculate polygon area */
+    getArea: (points: Point2D_2[]) => {
+        value: number;
+        formatted: string;
+    };
+    /** Calculate polyline length */
+    getLength: (points: Point2D_2[]) => {
+        value: number;
+        formatted: string;
+    };
+}
+
+export declare function useSnapToGrid(options?: UseSnapToGridOptions): UseSnapToGridReturn;
+
+declare interface UseSnapToGridOptions {
+    /** Grid size in pixels */
+    gridSize?: number;
+    /** Enable snap */
+    enabled?: boolean;
+    /** Active snap modes */
+    snapModes?: SnapMode[];
+    /** Existing objects for alignment guides */
+    objects?: BoundingBox[];
+    /** Snap threshold distance */
+    threshold?: number;
+}
+
+declare interface UseSnapToGridReturn {
+    /** Snap a point to grid */
+    snap: (point: Point2D_2) => Point2D_2;
+    /** Snap a 3D point to grid */
+    snap3D: (point: {
+        x: number;
+        y: number;
+        z: number;
+    }) => {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Get alignment guides for a point */
+    getGuides: (point: Point2D_2) => AlignmentGuide[];
+    /** Perform advanced snap with mode support */
+    performAdvancedSnap: (point: Point2D_2) => {
+        point: Point2D_2;
+        snapped: boolean;
+        guides: AlignmentGuide[];
+    };
+    /** Generate grid lines */
+    generateGridLines: (width: number, height: number) => Array<{
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    }>;
+}
+
+export declare function useSpatialEditor(options?: UseSpatialEditorOptions): UseSpatialEditorReturn;
+
+declare interface UseSpatialEditorOptions {
+    initialDocument?: FloorPlanDocument;
+    defaultMode?: SpatialEditorMode;
+    gridSize?: number;
+    snapEnabled?: boolean;
+    onChange?: (document: FloorPlanDocument) => void;
+}
+
+declare interface UseSpatialEditorReturn {
+    state: SpatialEditorState;
+    setMode: (mode: SpatialEditorMode) => void;
+    setTool: (tool: SpatialTool) => void;
+    newDocument: (name?: string) => void;
+    loadDocument: (doc: FloorPlanDocument) => void;
+    zoom: (delta: number) => void;
+    pan: (delta: Point2D_2) => void;
+    resetView: () => void;
+    toggleGrid: () => void;
+    toggleSnap: () => void;
+    setGridSize: (size: number) => void;
+    setLayerVisible: (layerType: string, visible: boolean) => void;
+    setLayerLocked: (layerType: string, locked: boolean) => void;
+    select: (objectIds: string[]) => void;
+    clearSelection: () => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    copy: () => void;
+    paste: (position: Point2D_2) => void;
+    cut: () => void;
+}
+
+/**
+ * Viewport state
+ */
+export declare interface ViewportState {
+    /** Current zoom level (1 = 100%) */
+    zoom: number;
+    /** Pan offset in screen coordinates */
+    pan: Point2D_2;
+    /** Rotation (for 2D) or camera angle (for 3D) */
+    rotation: number;
+    /** Grid visibility */
+    showGrid: boolean;
+    /** Grid size */
+    gridSize: number;
+    /** Snap to grid enabled */
+    snapEnabled: boolean;
+    /** Active snap modes */
+    snapModes: SnapMode[];
+}
+
+export declare interface ZoneOccupancy {
+    zoneId: BuildingId;
+    occupied: boolean;
+    count?: number;
+    lastUpdated: string;
+}
+
+export declare type ZoneType = 'living_room' | 'bedroom' | 'master_bedroom' | 'kids_room' | 'bathroom' | 'kitchen' | 'dining_room' | 'hallway' | 'office' | 'garage' | 'basement' | 'attic' | 'balcony' | 'garden' | 'laundry' | 'storage' | 'gym' | 'cinema' | 'open_office' | 'private_office' | 'meeting_room' | 'boardroom' | 'reception' | 'waiting_area' | 'server_room' | 'it_room' | 'break_room' | 'lobby' | 'corridor' | 'stairwell' | 'parking' | 'cafeteria' | 'mechanical_room' | 'other';
+
+export { }