@fastybird/smart-panel-backend 0.12.0-alpha.0 → 1.0.0-beta.2

package/dist/plugins/spaces-home-control/controllers/spaces-domain.controller.js

@@ -0,0 +1,1958 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpacesDomainController = void 0;
+const uuid_1 = require("uuid");
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const swagger_1 = require("@nestjs/swagger");
+const logger_1 = require("../../../common/logger");
+const spaces_response_model_1 = require("../../../modules/spaces/models/spaces-response.model");
+const spaces_service_1 = require("../../../modules/spaces/services/spaces.service");
+const spaces_exceptions_1 = require("../../../modules/spaces/spaces.exceptions");
+const api_documentation_decorator_1 = require("../../../modules/swagger/decorators/api-documentation.decorator");
+const roles_guard_1 = require("../../../modules/users/guards/roles.guard");
+const users_constants_1 = require("../../../modules/users/users.constants");
+const climate_intent_dto_1 = require("../dto/climate-intent.dto");
+const climate_role_dto_1 = require("../dto/climate-role.dto");
+const covers_intent_dto_1 = require("../dto/covers-intent.dto");
+const covers_role_dto_1 = require("../dto/covers-role.dto");
+const lighting_intent_dto_1 = require("../dto/lighting-intent.dto");
+const lighting_role_dto_1 = require("../dto/lighting-role.dto");
+const media_activity_binding_dto_1 = require("../dto/media-activity-binding.dto");
+const sensor_role_dto_1 = require("../dto/sensor-role.dto");
+const suggestion_dto_1 = require("../dto/suggestion.dto");
+const derived_media_endpoint_model_1 = require("../models/derived-media-endpoint.model");
+const media_activity_binding_model_1 = require("../models/media-activity-binding.model");
+const media_activity_model_1 = require("../models/media-activity.model");
+const spaces_response_model_2 = require("../models/spaces-response.model");
+const derived_media_endpoint_service_1 = require("../services/derived-media-endpoint.service");
+const home_control_spaces_service_1 = require("../services/home-control-spaces.service");
+const space_climate_role_service_1 = require("../services/space-climate-role.service");
+const space_context_snapshot_service_1 = require("../services/space-context-snapshot.service");
+const space_covers_role_service_1 = require("../services/space-covers-role.service");
+const space_intent_service_1 = require("../services/space-intent.service");
+const space_lighting_role_service_1 = require("../services/space-lighting-role.service");
+const space_lighting_state_service_1 = require("../services/space-lighting-state.service");
+const space_media_activity_binding_service_1 = require("../services/space-media-activity-binding.service");
+const space_media_activity_service_1 = require("../services/space-media-activity.service");
+const space_sensor_role_service_1 = require("../services/space-sensor-role.service");
+const space_sensor_state_service_1 = require("../services/space-sensor-state.service");
+const space_suggestion_heartbeat_service_1 = require("../services/space-suggestion-heartbeat.service");
+const space_suggestion_service_1 = require("../services/space-suggestion.service");
+const space_undo_history_service_1 = require("../services/space-undo-history.service");
+const spaces_home_control_constants_1 = require("../spaces-home-control.constants");
+const spaces_home_control_constants_2 = require("../spaces-home-control.constants");
+const spec_1 = require("../spec");
+let SpacesDomainController = class SpacesDomainController {
+    constructor(spacesService, homeControlSpacesService, spaceIntentService, spaceLightingRoleService, spaceLightingStateService, spaceClimateRoleService, spaceCoversRoleService, spaceSensorRoleService, spaceSensorStateService, spaceSuggestionService, spaceSuggestionHeartbeatService, spaceContextSnapshotService, spaceUndoHistoryService, intentSpecLoaderService, derivedMediaEndpointService, spaceMediaActivityBindingService, spaceMediaActivityService, eventEmitter) {
+        this.spacesService = spacesService;
+        this.homeControlSpacesService = homeControlSpacesService;
+        this.spaceIntentService = spaceIntentService;
+        this.spaceLightingRoleService = spaceLightingRoleService;
+        this.spaceLightingStateService = spaceLightingStateService;
+        this.spaceClimateRoleService = spaceClimateRoleService;
+        this.spaceCoversRoleService = spaceCoversRoleService;
+        this.spaceSensorRoleService = spaceSensorRoleService;
+        this.spaceSensorStateService = spaceSensorStateService;
+        this.spaceSuggestionService = spaceSuggestionService;
+        this.spaceSuggestionHeartbeatService = spaceSuggestionHeartbeatService;
+        this.spaceContextSnapshotService = spaceContextSnapshotService;
+        this.spaceUndoHistoryService = spaceUndoHistoryService;
+        this.intentSpecLoaderService = intentSpecLoaderService;
+        this.derivedMediaEndpointService = derivedMediaEndpointService;
+        this.spaceMediaActivityBindingService = spaceMediaActivityBindingService;
+        this.spaceMediaActivityService = spaceMediaActivityService;
+        this.eventEmitter = eventEmitter;
+        this.logger = (0, logger_1.createExtensionLogger)(spaces_home_control_constants_2.SPACES_HOME_CONTROL_PLUGIN_NAME, 'SpacesDomainController');
+    }
+    async proposeSpaces() {
+        this.logger.debug('Proposing spaces from device names');
+        const proposals = await this.homeControlSpacesService.proposeSpaces();
+        const response = new spaces_response_model_2.ProposedSpacesResponseModel();
+        response.data = proposals.map((p) => {
+            const model = new spaces_response_model_2.ProposedSpaceDataModel();
+            model.name = p.name;
+            model.type = p.type;
+            model.category = p.category;
+            model.deviceIds = p.deviceIds;
+            model.deviceCount = p.deviceCount;
+            return model;
+        });
+        return response;
+    }
+    getCategoryTemplates() {
+        this.logger.debug('Fetching category templates');
+        const templates = Object.entries(spaces_home_control_constants_1.SPACE_CATEGORY_TEMPLATES).map(([category, template]) => {
+            const model = new spaces_response_model_1.CategoryTemplateDataModel();
+            model.category = category;
+            model.icon = template.icon;
+            model.description = template.description;
+            return model;
+        });
+        const response = new spaces_response_model_1.CategoryTemplatesResponseModel();
+        response.data = templates;
+        return response;
+    }
+    async findAllZones() {
+        this.logger.debug('Fetching all zones');
+        const zones = await this.homeControlSpacesService.findAllZones();
+        const response = new spaces_response_model_1.SpacesResponseModel();
+        response.data = zones;
+        return response;
+    }
+    async findChildren(id) {
+        this.logger.debug(`Fetching child rooms for zone with id=${id}`);
+        const children = await this.homeControlSpacesService.getChildRooms(id);
+        const response = new spaces_response_model_1.SpacesResponseModel();
+        response.data = children;
+        return response;
+    }
+    async findParent(id) {
+        this.logger.debug(`Fetching parent zone for room with id=${id}`);
+        const parent = await this.homeControlSpacesService.getParentZone(id);
+        const response = new spaces_response_model_1.SpaceResponseModel();
+        response.data = parent;
+        return response;
+    }
+    getIntentCatalog() {
+        this.logger.debug('Fetching intent catalog');
+        const intentCatalog = this.intentSpecLoaderService.getIntentCatalog();
+        const categories = intentCatalog.map((cat) => {
+            const categoryData = new spaces_response_model_2.IntentCategoryDataModel();
+            categoryData.category = cat.category;
+            categoryData.label = cat.label;
+            categoryData.description = cat.description;
+            categoryData.icon = cat.icon;
+            categoryData.intents = cat.intents.map((intent) => {
+                const intentData = new spaces_response_model_2.IntentTypeDataModel();
+                intentData.type = intent.type;
+                intentData.label = intent.label;
+                intentData.description = intent.description;
+                intentData.icon = intent.icon;
+                intentData.params = intent.params.map((param) => {
+                    const paramData = new spaces_response_model_2.IntentParamDataModel();
+                    paramData.name = param.name;
+                    paramData.type = param.type;
+                    paramData.required = param.required;
+                    paramData.description = param.description;
+                    paramData.minValue = param.minValue;
+                    paramData.maxValue = param.maxValue;
+                    if (param.enumValues) {
+                        paramData.enumValues = param.enumValues.map((ev) => {
+                            const enumData = new spaces_response_model_2.IntentEnumValueDataModel();
+                            enumData.value = ev.value;
+                            enumData.label = ev.label;
+                            enumData.description = ev.description;
+                            enumData.icon = ev.icon;
+                            return enumData;
+                        });
+                    }
+                    return paramData;
+                });
+                return intentData;
+            });
+            return categoryData;
+        });
+        const quickActions = spaces_home_control_constants_1.QUICK_ACTION_CATALOG.map((qa) => {
+            const actionData = new spaces_response_model_2.QuickActionDataModel();
+            actionData.type = qa.type;
+            actionData.label = qa.label;
+            actionData.description = qa.description;
+            actionData.icon = qa.icon;
+            actionData.category = qa.category;
+            return actionData;
+        });
+        const lightingRolesFromSpec = this.intentSpecLoaderService
+            .getIntentCatalog()
+            .find((c) => c.category === 'lighting');
+        const roleParam = lightingRolesFromSpec?.intents
+            .find((i) => i.type === 'role_on')
+            ?.params.find((p) => p.name === 'role');
+        const lightingRoles = (roleParam?.enumValues ?? []).map((role) => {
+            const roleData = new spaces_response_model_2.LightingRoleMetaDataModel();
+            roleData.value = role.value;
+            roleData.label = role.label;
+            roleData.description = role.description;
+            roleData.icon = role.icon;
+            return roleData;
+        });
+        const lightingModesMap = this.intentSpecLoaderService.getAllLightingModeOrchestrations();
+        const lightingModes = [];
+        for (const [modeKey, modeConfig] of lightingModesMap) {
+            const modeData = new spaces_response_model_2.LightingModeOrchestrationDataModel();
+            modeData.mode = modeKey;
+            modeData.label = modeConfig.label;
+            modeData.description = modeConfig.description;
+            modeData.icon = modeConfig.icon;
+            modeData.mvpBrightness = modeConfig.mvpBrightness;
+            modeData.fallbackRoles = modeConfig.fallbackRoles;
+            modeData.fallbackBrightness = modeConfig.fallbackBrightness;
+            const roles = {};
+            for (const [roleKey, roleRule] of Object.entries(modeConfig.roles)) {
+                const ruleData = new spaces_response_model_2.LightingRoleBrightnessRuleDataModel();
+                ruleData.on = roleRule.on;
+                ruleData.brightness = roleRule.brightness;
+                roles[roleKey] = ruleData;
+            }
+            modeData.roles = roles;
+            lightingModes.push(modeData);
+        }
+        const coversModesMap = this.intentSpecLoaderService.getAllCoversModeOrchestrations();
+        const coversModes = [];
+        for (const [modeKey, modeConfig] of coversModesMap) {
+            const modeData = new spaces_response_model_2.CoversModeOrchestrationDataModel();
+            modeData.mode = modeKey;
+            modeData.label = modeConfig.label;
+            modeData.description = modeConfig.description;
+            modeData.icon = modeConfig.icon;
+            modeData.mvpPosition = modeConfig.mvpPosition;
+            const roles = {};
+            for (const [roleKey, roleRule] of Object.entries(modeConfig.roles)) {
+                const ruleData = new spaces_response_model_2.CoversRolePositionRuleDataModel();
+                ruleData.position = roleRule.position;
+                ruleData.tilt = roleRule.tilt;
+                roles[roleKey] = ruleData;
+            }
+            modeData.roles = roles;
+            coversModes.push(modeData);
+        }
+        const catalogData = new spaces_response_model_2.IntentCatalogDataModel();
+        catalogData.categories = categories;
+        catalogData.quickActions = quickActions;
+        catalogData.lightingRoles = lightingRoles;
+        catalogData.lightingModes = lightingModes;
+        catalogData.coversModes = coversModes;
+        const response = new spaces_response_model_2.IntentCatalogResponseModel();
+        response.data = catalogData;
+        return response;
+    }
+    async executeLightingIntent(id, body) {
+        this.logger.debug(`Executing lighting intent for space with id=${id}`);
+        const result = await this.spaceIntentService.executeLightingIntent(id, body.data);
+        if (!result) {
+            throw new spaces_exceptions_1.SpacesNotFoundException('Space not found');
+        }
+        const resultData = new spaces_response_model_2.LightingIntentResultDataModel();
+        resultData.success = result.success;
+        resultData.affectedDevices = result.affectedDevices;
+        resultData.failedDevices = result.failedDevices;
+        resultData.skippedOfflineDevices = result.skippedOfflineDevices;
+        resultData.offlineDeviceIds = result.offlineDeviceIds;
+        resultData.failedTargets = result.failedTargets ?? null;
+        const response = new spaces_response_model_2.LightingIntentResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async getClimateState(id) {
+        this.logger.debug(`Fetching climate state for space with id=${id}`);
+        const state = await this.spaceIntentService.getClimateState(id);
+        if (!state) {
+            throw new spaces_exceptions_1.SpacesNotFoundException('Space not found');
+        }
+        const stateData = new spaces_response_model_2.ClimateStateDataModel();
+        stateData.hasClimate = state.hasClimate;
+        stateData.mode = state.mode;
+        stateData.currentTemperature = state.currentTemperature;
+        stateData.currentHumidity = state.currentHumidity;
+        stateData.heatingSetpoint = state.heatingSetpoint;
+        stateData.coolingSetpoint = state.coolingSetpoint;
+        stateData.minSetpoint = state.minSetpoint;
+        stateData.maxSetpoint = state.maxSetpoint;
+        stateData.supportsHeating = state.supportsHeating;
+        stateData.supportsCooling = state.supportsCooling;
+        stateData.isHeating = state.isHeating;
+        stateData.isCooling = state.isCooling;
+        stateData.isMixed = state.isMixed;
+        stateData.devicesCount = state.devicesCount;
+        const response = new spaces_response_model_2.ClimateStateResponseModel();
+        response.data = stateData;
+        return response;
+    }
+    async executeClimateIntent(id, body) {
+        this.logger.debug(`Executing climate intent for space with id=${id}, ` +
+            `type=${body.data.type}, mode=${body.data.mode}, ` +
+            `heatingSetpoint=${body.data.heatingSetpoint}, coolingSetpoint=${body.data.coolingSetpoint}`);
+        const result = await this.spaceIntentService.executeClimateIntent(id, body.data);
+        if (!result) {
+            throw new spaces_exceptions_1.SpacesNotFoundException('Space not found');
+        }
+        const resultData = new spaces_response_model_2.ClimateIntentResultDataModel();
+        resultData.success = result.success;
+        resultData.affectedDevices = result.affectedDevices;
+        resultData.failedDevices = result.failedDevices;
+        resultData.skippedOfflineDevices = result.skippedOfflineDevices;
+        resultData.offlineDeviceIds = result.offlineDeviceIds;
+        resultData.failedTargets = result.failedTargets ?? null;
+        resultData.mode = result.mode;
+        resultData.heatingSetpoint = result.heatingSetpoint;
+        resultData.coolingSetpoint = result.coolingSetpoint;
+        const response = new spaces_response_model_2.ClimateIntentResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async getLightingState(id) {
+        this.logger.debug(`Fetching lighting state for space with id=${id}`);
+        const state = await this.spaceLightingStateService.getLightingState(id);
+        if (!state) {
+            throw new spaces_exceptions_1.SpacesNotFoundException('Space not found');
+        }
+        const stateData = new spaces_response_model_2.LightingStateDataModel();
+        stateData.hasLights = state.hasLights;
+        stateData.detectedMode = state.detectedMode;
+        stateData.modeConfidence = state.modeConfidence;
+        stateData.modeMatchPercentage = state.modeMatchPercentage;
+        stateData.isModeFromIntent = state.isModeFromIntent;
+        stateData.lastAppliedMode = state.lastAppliedMode;
+        stateData.lastAppliedAt = state.lastAppliedAt;
+        stateData.totalLights = state.totalLights;
+        stateData.lightsOn = state.lightsOn;
+        stateData.averageBrightness = state.averageBrightness;
+        stateData.lightsByRole = state.lightsByRole;
+        const rolesMap = new spaces_response_model_2.RolesStateMapDataModel();
+        for (const [roleKey, roleState] of Object.entries(state.roles)) {
+            const roleData = new spaces_response_model_2.RoleAggregatedStateDataModel();
+            roleData.role = roleState.role;
+            roleData.isOn = roleState.isOn;
+            roleData.isOnMixed = roleState.isOnMixed;
+            roleData.brightness = roleState.brightness;
+            roleData.colorTemperature = roleState.colorTemperature;
+            roleData.color = roleState.color;
+            roleData.white = roleState.white;
+            roleData.isBrightnessMixed = roleState.isBrightnessMixed;
+            roleData.isColorTemperatureMixed = roleState.isColorTemperatureMixed;
+            roleData.isColorMixed = roleState.isColorMixed;
+            roleData.isWhiteMixed = roleState.isWhiteMixed;
+            roleData.lastIntent = roleState.lastIntent;
+            roleData.devicesCount = roleState.devicesCount;
+            roleData.devicesOn = roleState.devicesOn;
+            rolesMap[roleKey] = roleData;
+        }
+        stateData.roles = rolesMap;
+        const otherData = new spaces_response_model_2.OtherLightsStateDataModel();
+        otherData.isOn = state.other.isOn;
+        otherData.isOnMixed = state.other.isOnMixed;
+        otherData.brightness = state.other.brightness;
+        otherData.colorTemperature = state.other.colorTemperature;
+        otherData.color = state.other.color;
+        otherData.white = state.other.white;
+        otherData.isBrightnessMixed = state.other.isBrightnessMixed;
+        otherData.isColorTemperatureMixed = state.other.isColorTemperatureMixed;
+        otherData.isColorMixed = state.other.isColorMixed;
+        otherData.isWhiteMixed = state.other.isWhiteMixed;
+        otherData.devicesCount = state.other.devicesCount;
+        otherData.devicesOn = state.other.devicesOn;
+        stateData.other = otherData;
+        const response = new spaces_response_model_2.LightingStateResponseModel();
+        response.data = stateData;
+        return response;
+    }
+    async getLightTargets(id) {
+        this.logger.debug(`Fetching light targets for space with id=${id}`);
+        const targets = await this.spaceLightingRoleService.getLightTargetsInSpace(id);
+        const response = new spaces_response_model_2.LightTargetsResponseModel();
+        response.data = targets.map((t) => {
+            const model = new spaces_response_model_2.LightTargetDataModel();
+            model.deviceId = t.deviceId;
+            model.deviceName = t.deviceName;
+            model.channelId = t.channelId;
+            model.channelName = t.channelName;
+            model.role = t.role;
+            model.priority = t.priority;
+            model.hasBrightness = t.hasBrightness;
+            model.hasColorTemp = t.hasColorTemp;
+            model.hasColor = t.hasColor;
+            return model;
+        });
+        return response;
+    }
+    async setLightingRole(id, body) {
+        this.logger.debug(`Setting lighting role for space with id=${id}`);
+        const role = await this.spaceLightingRoleService.setRole(id, body.data);
+        const response = new spaces_response_model_2.LightingRoleResponseModel();
+        response.data = role;
+        return response;
+    }
+    async bulkSetLightingRoles(id, body) {
+        this.logger.debug(`Bulk setting lighting roles for space with id=${id}`);
+        const result = await this.spaceLightingRoleService.bulkSetRoles(id, body.data.roles);
+        const resultData = new spaces_response_model_2.BulkLightingRolesResultDataModel();
+        resultData.success = result.success;
+        resultData.totalCount = result.totalCount;
+        resultData.successCount = result.successCount;
+        resultData.failureCount = result.failureCount;
+        resultData.results = result.results.map((item) => {
+            const resultItem = new spaces_response_model_2.BulkLightingRoleResultItemModel();
+            resultItem.deviceId = item.deviceId;
+            resultItem.channelId = item.channelId;
+            resultItem.success = item.success;
+            resultItem.role = item.role;
+            resultItem.error = item.error;
+            return resultItem;
+        });
+        const response = new spaces_response_model_2.BulkLightingRolesResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async applyDefaultLightingRoles(id) {
+        this.logger.debug(`Applying default lighting roles for space with id=${id}`);
+        const defaultRoles = await this.spaceLightingRoleService.inferDefaultLightingRoles(id);
+        const result = await this.spaceLightingRoleService.bulkSetRoles(id, defaultRoles);
+        const resultData = new spaces_response_model_2.BulkLightingRolesResultDataModel();
+        resultData.success = result.success;
+        resultData.totalCount = result.totalCount;
+        resultData.successCount = result.successCount;
+        resultData.failureCount = result.failureCount;
+        resultData.results = result.results.map((item) => {
+            const resultItem = new spaces_response_model_2.BulkLightingRoleResultItemModel();
+            resultItem.deviceId = item.deviceId;
+            resultItem.channelId = item.channelId;
+            resultItem.success = item.success;
+            resultItem.role = item.role;
+            resultItem.error = item.error;
+            return resultItem;
+        });
+        const response = new spaces_response_model_2.BulkLightingRolesResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async deleteLightingRole(id, deviceId, channelId) {
+        this.logger.debug(`Deleting lighting role for space=${id} device=${deviceId} channel=${channelId}`);
+        await this.spaceLightingRoleService.deleteRole(id, deviceId, channelId);
+        this.logger.debug(`Successfully deleted lighting role for device=${deviceId} channel=${channelId}`);
+    }
+    async getClimateTargets(id) {
+        this.logger.debug(`Fetching climate targets for space with id=${id}`);
+        const targets = await this.spaceClimateRoleService.getClimateTargetsInSpace(id);
+        const response = new spaces_response_model_2.ClimateTargetsResponseModel();
+        response.data = targets.map((t) => {
+            const model = new spaces_response_model_2.ClimateTargetDataModel();
+            model.deviceId = t.deviceId;
+            model.deviceName = t.deviceName;
+            model.deviceCategory = t.deviceCategory;
+            model.channelId = t.channelId;
+            model.channelName = t.channelName;
+            model.channelCategory = t.channelCategory;
+            model.role = t.role;
+            model.priority = t.priority;
+            model.hasTemperature = t.hasTemperature;
+            model.hasHumidity = t.hasHumidity;
+            model.hasAirQuality = t.hasAirQuality;
+            model.hasAirParticulate = t.hasAirParticulate;
+            model.hasCarbonDioxide = t.hasCarbonDioxide;
+            model.hasVolatileOrganicCompounds = t.hasVolatileOrganicCompounds;
+            model.hasPressure = t.hasPressure;
+            model.hasMode = t.hasMode;
+            return model;
+        });
+        return response;
+    }
+    async setClimateRole(id, body) {
+        this.logger.debug(`Setting climate role for space with id=${id}`);
+        const role = await this.spaceClimateRoleService.setRole(id, body.data);
+        const response = new spaces_response_model_2.ClimateRoleResponseModel();
+        response.data = role;
+        return response;
+    }
+    async bulkSetClimateRoles(id, body) {
+        this.logger.debug(`Bulk setting climate roles for space with id=${id}`);
+        const result = await this.spaceClimateRoleService.bulkSetRoles(id, body.data.roles);
+        const resultData = new spaces_response_model_2.BulkClimateRolesResultDataModel();
+        resultData.success = result.success;
+        resultData.totalCount = result.totalCount;
+        resultData.successCount = result.successCount;
+        resultData.failureCount = result.failureCount;
+        resultData.results = result.results.map((item) => {
+            const resultItem = new spaces_response_model_2.BulkClimateRoleResultItemModel();
+            resultItem.deviceId = item.deviceId;
+            resultItem.channelId = item.channelId;
+            resultItem.success = item.success;
+            resultItem.role = item.role;
+            resultItem.error = item.error;
+            return resultItem;
+        });
+        const response = new spaces_response_model_2.BulkClimateRolesResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async applyDefaultClimateRoles(id) {
+        this.logger.debug(`Applying default climate roles for space with id=${id}`);
+        const defaultRoles = await this.spaceClimateRoleService.inferDefaultClimateRoles(id);
+        const result = await this.spaceClimateRoleService.bulkSetRoles(id, defaultRoles);
+        const resultData = new spaces_response_model_2.BulkClimateRolesResultDataModel();
+        resultData.success = result.success;
+        resultData.totalCount = result.totalCount;
+        resultData.successCount = result.successCount;
+        resultData.failureCount = result.failureCount;
+        resultData.results = result.results.map((item) => {
+            const resultItem = new spaces_response_model_2.BulkClimateRoleResultItemModel();
+            resultItem.deviceId = item.deviceId;
+            resultItem.channelId = item.channelId;
+            resultItem.success = item.success;
+            resultItem.role = item.role;
+            resultItem.error = item.error;
+            return resultItem;
+        });
+        const response = new spaces_response_model_2.BulkClimateRolesResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async deleteClimateRole(id, deviceId, channelId) {
+        this.logger.debug(`Deleting climate role for space=${id} device=${deviceId} channel=${channelId ?? 'null'}`);
+        await this.spaceClimateRoleService.deleteRole(id, deviceId, channelId);
+        this.logger.debug(`Successfully deleted climate role for device=${deviceId} channel=${channelId ?? 'null'}`);
+    }
+    async getCoversState(id) {
+        this.logger.debug(`Fetching covers state for space with id=${id}`);
+        const state = await this.spaceIntentService.getCoversState(id);
+        if (!state) {
+            throw new spaces_exceptions_1.SpacesNotFoundException('Space not found');
+        }
+        const response = new spaces_response_model_2.CoversStateResponseModel();
+        response.data = spaces_response_model_2.CoversStateDataModel.fromState(state);
+        return response;
+    }
+    async executeCoversIntent(id, body) {
+        this.logger.debug(`Executing covers intent for space with id=${id}`);
+        const result = await this.spaceIntentService.executeCoversIntent(id, body.data);
+        if (!result) {
+            throw new spaces_exceptions_1.SpacesNotFoundException('Space not found');
+        }
+        const resultData = new spaces_response_model_2.CoversIntentResultDataModel();
+        resultData.success = result.success;
+        resultData.affectedDevices = result.affectedDevices;
+        resultData.failedDevices = result.failedDevices;
+        resultData.skippedOfflineDevices = result.skippedOfflineDevices;
+        resultData.offlineDeviceIds = result.offlineDeviceIds;
+        resultData.failedTargets = result.failedTargets ?? null;
+        resultData.newPosition = result.newPosition;
+        const response = new spaces_response_model_2.CoversIntentResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async getCoversTargets(id) {
+        this.logger.debug(`Fetching covers targets for space with id=${id}`);
+        const targets = await this.spaceCoversRoleService.getCoversTargetsInSpace(id);
+        const response = new spaces_response_model_2.CoversTargetsResponseModel();
+        response.data = targets.map((t) => {
+            const model = new spaces_response_model_2.CoversTargetDataModel();
+            model.deviceId = t.deviceId;
+            model.deviceName = t.deviceName;
+            model.channelId = t.channelId;
+            model.channelName = t.channelName;
+            model.role = t.role;
+            model.priority = t.priority;
+            model.hasPosition = t.hasPosition;
+            model.hasCommand = t.hasCommand;
+            model.hasTilt = t.hasTilt;
+            model.coverType = t.coverType;
+            return model;
+        });
+        return response;
+    }
+    async setCoversRole(id, body) {
+        this.logger.debug(`Setting covers role for space with id=${id}`);
+        const role = await this.spaceCoversRoleService.setRole(id, body.data);
+        const response = new spaces_response_model_2.CoversRoleResponseModel();
+        response.data = role;
+        return response;
+    }
+    async bulkSetCoversRoles(id, body) {
+        this.logger.debug(`Bulk setting covers roles for space with id=${id}`);
+        const result = await this.spaceCoversRoleService.bulkSetRoles(id, body.data.roles);
+        const resultData = new spaces_response_model_2.BulkCoversRolesResultDataModel();
+        resultData.success = result.success;
+        resultData.totalCount = result.totalCount;
+        resultData.successCount = result.successCount;
+        resultData.failureCount = result.failureCount;
+        resultData.results = result.results.map((item) => {
+            const resultItem = new spaces_response_model_2.BulkCoversRoleResultItemModel();
+            resultItem.deviceId = item.deviceId;
+            resultItem.channelId = item.channelId;
+            resultItem.success = item.success;
+            resultItem.role = item.role;
+            resultItem.error = item.error;
+            return resultItem;
+        });
+        const response = new spaces_response_model_2.BulkCoversRolesResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async applyDefaultCoversRoles(id) {
+        this.logger.debug(`Applying default covers roles for space with id=${id}`);
+        const defaultRoles = await this.spaceCoversRoleService.inferDefaultCoversRoles(id);
+        const result = await this.spaceCoversRoleService.bulkSetRoles(id, defaultRoles);
+        const resultData = new spaces_response_model_2.BulkCoversRolesResultDataModel();
+        resultData.success = result.success;
+        resultData.totalCount = result.totalCount;
+        resultData.successCount = result.successCount;
+        resultData.failureCount = result.failureCount;
+        resultData.results = result.results.map((item) => {
+            const resultItem = new spaces_response_model_2.BulkCoversRoleResultItemModel();
+            resultItem.deviceId = item.deviceId;
+            resultItem.channelId = item.channelId;
+            resultItem.success = item.success;
+            resultItem.role = item.role;
+            resultItem.error = item.error;
+            return resultItem;
+        });
+        const response = new spaces_response_model_2.BulkCoversRolesResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async deleteCoversRole(id, deviceId, channelId) {
+        this.logger.debug(`Deleting covers role for space=${id} device=${deviceId} channel=${channelId}`);
+        await this.spaceCoversRoleService.deleteRole(id, deviceId, channelId);
+        this.logger.debug(`Successfully deleted covers role for device=${deviceId} channel=${channelId}`);
+    }
+    async getSensorState(id) {
+        this.logger.debug(`Fetching sensor state for space with id=${id}`);
+        const state = await this.spaceSensorStateService.getSensorState(id);
+        if (!state) {
+            throw new spaces_exceptions_1.SpacesNotFoundException('Space not found');
+        }
+        const stateData = new spaces_response_model_2.SensorStateDataModel();
+        stateData.hasSensors = state.hasSensors;
+        stateData.totalSensors = state.totalSensors;
+        stateData.sensorsByRole = state.sensorsByRole;
+        if (state.environment) {
+            const envData = new spaces_response_model_2.EnvironmentSummaryDataModel();
+            envData.averageTemperature = state.environment.averageTemperature;
+            envData.averageHumidity = state.environment.averageHumidity;
+            envData.averagePressure = state.environment.averagePressure;
+            envData.averageIlluminance = state.environment.averageIlluminance;
+            stateData.environment = envData;
+        }
+        else {
+            stateData.environment = null;
+        }
+        stateData.safetyAlerts = state.safetyAlerts.map((alert) => {
+            const alertData = new spaces_response_model_2.SafetyAlertDataModel();
+            alertData.channelCategory = alert.channelCategory;
+            alertData.deviceId = alert.deviceId;
+            alertData.deviceName = alert.deviceName;
+            alertData.channelId = alert.channelId;
+            alertData.triggered = alert.triggered;
+            return alertData;
+        });
+        stateData.hasSafetyAlert = state.hasSafetyAlert;
+        stateData.motionDetected = state.motionDetected;
+        stateData.occupancyDetected = state.occupancyDetected;
+        stateData.readings = state.readings.map((roleReadings) => {
+            const roleData = new spaces_response_model_2.SensorRoleReadingsDataModel();
+            roleData.role = roleReadings.role;
+            roleData.sensorsCount = roleReadings.sensorsCount;
+            roleData.readings = roleReadings.readings.map((reading) => {
+                const readingData = new spaces_response_model_2.SensorReadingDataModel();
+                readingData.deviceId = reading.deviceId;
+                readingData.deviceName = reading.deviceName;
+                readingData.channelId = reading.channelId;
+                readingData.channelName = reading.channelName;
+                readingData.channelCategory = reading.channelCategory;
+                readingData.propertyId = reading.propertyId;
+                readingData.value = reading.value;
+                readingData.unit = reading.unit;
+                readingData.role = reading.role;
+                readingData.updatedAt = reading.updatedAt;
+                readingData.trend = reading.trend;
+                readingData.additionalReadings = reading.additionalReadings.map((ar) => {
+                    const arData = new spaces_response_model_2.SensorAdditionalReadingDataModel();
+                    arData.propertyId = ar.propertyId;
+                    arData.propertyCategory = ar.propertyCategory;
+                    arData.value = ar.value;
+                    arData.unit = ar.unit;
+                    arData.updatedAt = ar.updatedAt;
+                    arData.trend = ar.trend;
+                    return arData;
+                });
+                return readingData;
+            });
+            return roleData;
+        });
+        const response = new spaces_response_model_2.SensorStateResponseModel();
+        response.data = stateData;
+        return response;
+    }
+    async getSensorTargets(id) {
+        this.logger.debug(`Fetching sensor targets for space with id=${id}`);
+        const targets = await this.spaceSensorRoleService.getSensorTargetsInSpace(id);
+        const response = new spaces_response_model_2.SensorTargetsResponseModel();
+        response.data = targets.map((t) => {
+            const model = new spaces_response_model_2.SensorTargetDataModel();
+            model.deviceId = t.deviceId;
+            model.deviceName = t.deviceName;
+            model.deviceCategory = t.deviceCategory;
+            model.channelId = t.channelId;
+            model.channelName = t.channelName;
+            model.channelCategory = t.channelCategory;
+            model.role = t.role;
+            model.priority = t.priority;
+            return model;
+        });
+        return response;
+    }
+    async setSensorRole(id, body) {
+        this.logger.debug(`Setting sensor role for space with id=${id}`);
+        const role = await this.spaceSensorRoleService.setRole(id, body.data);
+        const response = new spaces_response_model_2.SensorRoleResponseModel();
+        response.data = role;
+        return response;
+    }
+    async bulkSetSensorRoles(id, body) {
+        this.logger.debug(`Bulk setting sensor roles for space with id=${id}`);
+        const result = await this.spaceSensorRoleService.bulkSetRoles(id, body.data.roles);
+        const resultData = new spaces_response_model_2.BulkSensorRolesResultDataModel();
+        resultData.success = result.success;
+        resultData.totalCount = result.totalCount;
+        resultData.successCount = result.successCount;
+        resultData.failureCount = result.failureCount;
+        resultData.results = result.results.map((item) => {
+            const resultItem = new spaces_response_model_2.BulkSensorRoleResultItemModel();
+            resultItem.deviceId = item.deviceId;
+            resultItem.channelId = item.channelId;
+            resultItem.success = item.success;
+            resultItem.role = item.role;
+            resultItem.error = item.error;
+            return resultItem;
+        });
+        const response = new spaces_response_model_2.BulkSensorRolesResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async applyDefaultSensorRoles(id) {
+        this.logger.debug(`Applying default sensor roles for space with id=${id}`);
+        const defaultRoles = await this.spaceSensorRoleService.inferDefaultSensorRoles(id);
+        const result = await this.spaceSensorRoleService.bulkSetRoles(id, defaultRoles);
+        const resultData = new spaces_response_model_2.BulkSensorRolesResultDataModel();
+        resultData.success = result.success;
+        resultData.totalCount = result.totalCount;
+        resultData.successCount = result.successCount;
+        resultData.failureCount = result.failureCount;
+        resultData.results = result.results.map((item) => {
+            const resultItem = new spaces_response_model_2.BulkSensorRoleResultItemModel();
+            resultItem.deviceId = item.deviceId;
+            resultItem.channelId = item.channelId;
+            resultItem.success = item.success;
+            resultItem.role = item.role;
+            resultItem.error = item.error;
+            return resultItem;
+        });
+        const response = new spaces_response_model_2.BulkSensorRolesResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async deleteSensorRole(id, deviceId, channelId) {
+        this.logger.debug(`Deleting sensor role for space=${id} device=${deviceId} channel=${channelId}`);
+        await this.spaceSensorRoleService.deleteRole(id, deviceId, channelId);
+        this.logger.debug(`Successfully deleted sensor role for device=${deviceId} channel=${channelId}`);
+    }
+    async getDerivedMediaEndpoints(id) {
+        this.logger.debug(`Fetching derived media endpoints for space with id=${id}`);
+        const result = await this.derivedMediaEndpointService.buildEndpointsForSpace(id);
+        const response = new derived_media_endpoint_model_1.DerivedMediaEndpointsResponseModel();
+        response.data = result;
+        return response;
+    }
+    async getSuggestion(id) {
+        this.logger.debug(`Getting suggestion for space with id=${id}`);
+        const suggestion = await this.spaceSuggestionService.getSuggestion(id);
+        const response = new spaces_response_model_2.SuggestionResponseModel();
+        if (suggestion) {
+            const suggestionData = new spaces_response_model_2.SuggestionDataModel();
+            suggestionData.type = suggestion.type;
+            suggestionData.title = suggestion.title;
+            suggestionData.reason = suggestion.reason;
+            suggestionData.intentType = suggestion.intentType;
+            suggestionData.intentMode = suggestion.intentMode;
+            response.data = suggestionData;
+        }
+        else {
+            response.data = null;
+        }
+        return response;
+    }
+    async submitSuggestionFeedback(id, body) {
+        this.logger.debug(`Submitting suggestion feedback for space with id=${id}`);
+        const result = await this.spaceSuggestionService.recordFeedback(id, body.data.suggestionType, body.data.feedback);
+        const resultData = new spaces_response_model_2.SuggestionFeedbackResultDataModel();
+        resultData.success = result.success;
+        resultData.intentExecuted = result.intentExecuted;
+        const response = new spaces_response_model_2.SuggestionFeedbackResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async captureContextSnapshot(id) {
+        this.logger.debug(`Capturing context snapshot for space with id=${id}`);
+        const snapshot = await this.spaceContextSnapshotService.captureSnapshot(id);
+        if (!snapshot) {
+            throw new spaces_exceptions_1.SpacesNotFoundException('Space not found');
+        }
+        const lightingSummary = new spaces_response_model_2.LightingSummaryDataModel();
+        lightingSummary.totalLights = snapshot.lighting.summary.totalLights;
+        lightingSummary.lightsOn = snapshot.lighting.summary.lightsOn;
+        lightingSummary.averageBrightness = snapshot.lighting.summary.averageBrightness;
+        const lights = snapshot.lighting.lights.map((light) => {
+            const lightData = new spaces_response_model_2.LightStateSnapshotDataModel();
+            lightData.deviceId = light.deviceId;
+            lightData.deviceName = light.deviceName;
+            lightData.channelId = light.channelId;
+            lightData.channelName = light.channelName;
+            lightData.role = light.role;
+            lightData.isOn = light.isOn;
+            lightData.brightness = light.brightness;
+            lightData.colorTemperature = light.colorTemperature;
+            lightData.color = light.color;
+            return lightData;
+        });
+        const lightingContext = new spaces_response_model_2.LightingContextDataModel();
+        lightingContext.summary = lightingSummary;
+        lightingContext.lights = lights;
+        const climateState = new spaces_response_model_2.ClimateStateDataModel();
+        climateState.hasClimate = snapshot.climate.hasClimate;
+        climateState.mode = snapshot.climate.mode;
+        climateState.currentTemperature = snapshot.climate.currentTemperature;
+        climateState.currentHumidity = snapshot.climate.currentHumidity;
+        climateState.heatingSetpoint = snapshot.climate.heatingSetpoint;
+        climateState.coolingSetpoint = snapshot.climate.coolingSetpoint;
+        climateState.minSetpoint = snapshot.climate.minSetpoint;
+        climateState.maxSetpoint = snapshot.climate.maxSetpoint;
+        climateState.supportsHeating = snapshot.climate.supportsHeating;
+        climateState.supportsCooling = snapshot.climate.supportsCooling;
+        climateState.isHeating = snapshot.climate.isHeating;
+        climateState.isCooling = snapshot.climate.isCooling;
+        climateState.isMixed = snapshot.climate.isMixed;
+        climateState.devicesCount = snapshot.climate.devicesCount;
+        const snapshotData = new spaces_response_model_2.ContextSnapshotDataModel();
+        snapshotData.spaceId = snapshot.spaceId;
+        snapshotData.spaceName = snapshot.spaceName;
+        snapshotData.capturedAt = snapshot.capturedAt;
+        snapshotData.lighting = lightingContext;
+        snapshotData.climate = climateState;
+        const response = new spaces_response_model_2.ContextSnapshotResponseModel();
+        response.data = snapshotData;
+        return response;
+    }
+    async getUndoState(id) {
+        this.logger.debug(`Fetching undo state for space with id=${id}`);
+        await this.spacesService.getOneOrThrow(id);
+        const undoEntry = this.spaceUndoHistoryService.peekUndoEntry(id);
+        const stateData = new spaces_response_model_2.UndoStateDataModel();
+        if (undoEntry) {
+            const ttlMs = this.spaceUndoHistoryService.getEntryTtlMs();
+            const expiresAt = new Date(undoEntry.capturedAt.getTime() + ttlMs);
+            const expiresInMs = expiresAt.getTime() - Date.now();
+            const expiresInSeconds = Math.max(0, Math.floor(expiresInMs / 1000));
+            stateData.canUndo = true;
+            stateData.actionDescription = undoEntry.actionDescription;
+            stateData.intentCategory = undoEntry.intentCategory;
+            stateData.capturedAt = undoEntry.capturedAt;
+            stateData.expiresInSeconds = expiresInSeconds;
+        }
+        else {
+            stateData.canUndo = false;
+            stateData.actionDescription = null;
+            stateData.intentCategory = null;
+            stateData.capturedAt = null;
+            stateData.expiresInSeconds = null;
+        }
+        const response = new spaces_response_model_2.UndoStateResponseModel();
+        response.data = stateData;
+        return response;
+    }
+    async executeUndo(id) {
+        this.logger.debug(`Executing undo for space with id=${id}`);
+        await this.spacesService.getOneOrThrow(id);
+        const result = await this.spaceUndoHistoryService.executeUndo(id);
+        const resultData = new spaces_response_model_2.UndoResultDataModel();
+        resultData.success = result.success;
+        resultData.restoredDevices = result.restoredDevices;
+        resultData.failedDevices = result.failedDevices;
+        resultData.message = result.message;
+        const response = new spaces_response_model_2.UndoResultResponseModel();
+        response.data = resultData;
+        return response;
+    }
+    async getMediaActivityBindings(id) {
+        this.logger.debug(`Fetching media activity bindings for space with id=${id}`);
+        const bindings = await this.spaceMediaActivityBindingService.findBySpace(id);
+        const response = new media_activity_binding_model_1.MediaActivityBindingsResponseModel();
+        response.data = bindings;
+        return response;
+    }
+    async applyDefaultMediaActivityBindings(id) {
+        this.logger.debug(`Applying default media activity bindings for space=${id}`);
+        const bindings = await this.spaceMediaActivityBindingService.applyDefaults(id);
+        const response = new media_activity_binding_model_1.MediaActivityBindingsResponseModel();
+        response.data = bindings;
+        return response;
+    }
+    async validateMediaActivityBindings(id) {
+        this.logger.debug(`Validating media activity bindings for space=${id}`);
+        const reports = await this.spaceMediaActivityBindingService.validateBindings(id);
+        const data = reports.map((r) => {
+            const report = new media_activity_binding_model_1.BindingValidationReportModel();
+            report.activityKey = r.activityKey;
+            report.bindingId = r.bindingId;
+            report.valid = r.valid;
+            report.issues = r.issues;
+            return report;
+        });
+        const response = new media_activity_binding_model_1.BindingValidationResponseModel();
+        response.data = data;
+        return response;
+    }
+    async getMediaActivityBinding(id, bindingId) {
+        this.logger.debug(`Fetching media activity binding id=${bindingId} for space=${id}`);
+        const binding = await this.spaceMediaActivityBindingService.getOneOrThrowForSpace(id, bindingId);
+        const response = new media_activity_binding_model_1.MediaActivityBindingResponseModel();
+        response.data = binding;
+        return response;
+    }
+    async createMediaActivityBinding(id, body) {
+        this.logger.debug(`Creating media activity binding for space=${id} key=${body.data.activityKey}`);
+        const binding = await this.spaceMediaActivityBindingService.create(id, body.data);
+        const response = new media_activity_binding_model_1.MediaActivityBindingResponseModel();
+        response.data = binding;
+        return response;
+    }
+    async updateMediaActivityBinding(id, bindingId, body) {
+        this.logger.debug(`Updating media activity binding id=${bindingId} for space=${id}`);
+        const binding = await this.spaceMediaActivityBindingService.updateForSpace(id, bindingId, body.data);
+        const response = new media_activity_binding_model_1.MediaActivityBindingResponseModel();
+        response.data = binding;
+        return response;
+    }
+    async deleteMediaActivityBinding(id, bindingId) {
+        this.logger.debug(`Deleting media activity binding id=${bindingId} for space=${id}`);
+        await this.spaceMediaActivityBindingService.deleteForSpace(id, bindingId);
+    }
+    async getActiveMediaActivity(id) {
+        this.logger.debug(`Fetching active media activity for space=${id}`);
+        const record = await this.spaceMediaActivityService.getActive(id);
+        const response = new media_activity_model_1.ActiveMediaActivityResponseModel();
+        response.data = record;
+        return response;
+    }
+    async previewMediaActivity(id, activityKey) {
+        this.logger.debug(`Dry-run preview media activity=${activityKey} for space=${id}`);
+        const preview = await this.spaceMediaActivityService.preview(id, activityKey);
+        const response = new media_activity_model_1.MediaActivityDryRunPreviewResponseModel();
+        response.data = preview;
+        return response;
+    }
+    async activateMediaActivity(id, activityKey) {
+        this.logger.debug(`Activating media activity=${activityKey} for space=${id}`);
+        const result = await this.spaceMediaActivityService.activate(id, activityKey);
+        const response = new media_activity_model_1.MediaActivityActivationResponseModel();
+        response.data = result;
+        return response;
+    }
+    async deactivateMediaActivity(id) {
+        this.logger.debug(`Deactivating media activity for space=${id}`);
+        const result = await this.spaceMediaActivityService.deactivate(id);
+        const response = new media_activity_model_1.MediaActivityActivationResponseModel();
+        response.data = result;
+        return response;
+    }
+    async triggerSuggestionHeartbeat() {
+        this.logger.debug('Manually triggering suggestion heartbeat cycle');
+        await this.spaceSuggestionHeartbeatService.runCycle();
+        return { data: { triggered: true } };
+    }
+    async emitTestSuggestion(body) {
+        let space;
+        if (body?.data?.space_id) {
+            space = await this.spacesService.findOne(body.data.space_id);
+        }
+        if (!space) {
+            const spaces = await this.spacesService.findAll();
+            space = spaces[0];
+        }
+        if (!space) {
+            return { data: { emitted: false } };
+        }
+        const event = {
+            id: (0, uuid_1.v4)(),
+            type: spaces_home_control_constants_1.SuggestionType.LIGHTING_RELAX,
+            title: 'Relax lighting',
+            reason: 'Evening time — switch to a calmer lighting mode',
+            intent_type: 'set_mode',
+            intent_mode: 'relax',
+            space_id: space.id,
+            created_at: new Date().toISOString(),
+            expires_at: new Date(Date.now() + spaces_home_control_constants_1.SUGGESTION_EXPIRY_MS).toISOString(),
+        };
+        this.eventEmitter.emit(spaces_home_control_constants_1.EventType.SUGGESTION_CREATED, event);
+        this.logger.debug(`Test suggestion emitted for space id=${space.id}`);
+        return { data: { emitted: true, space_id: space.id } };
+    }
+};
+exports.SpacesDomainController = SpacesDomainController;
+__decorate([
+    (0, common_1.Get)('propose'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-propose',
+        summary: 'Propose spaces from device names',
+        description: 'Analyzes device names and proposes space (room) names based on common patterns. ' +
+            'Returns a list of proposed spaces with matching device IDs. Requires owner or admin role.',
+    }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.ProposedSpacesResponseModel, 'Returns proposed spaces'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "proposeSpaces", null);
+__decorate([
+    (0, common_1.Get)('categories/templates'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-category-templates',
+        summary: 'List space category templates',
+        description: 'Retrieves all available space category templates with their default icons and descriptions. ' +
+            'Templates provide suggested values when creating spaces of common room types.',
+    }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_1.CategoryTemplatesResponseModel, 'Returns category templates'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", spaces_response_model_1.CategoryTemplatesResponseModel)
+], SpacesDomainController.prototype, "getCategoryTemplates", null);
+__decorate([
+    (0, common_1.Get)('zones'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-zones',
+        summary: 'List all zones',
+        description: 'Retrieves all spaces of type zone. Useful for parent selection dropdowns.',
+    }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_1.SpacesResponseModel, 'Returns a list of zones'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "findAllZones", null);
+__decorate([
+    (0, common_1.Get)(':id/children'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-children',
+        summary: 'List child rooms of a zone',
+        description: 'Retrieves all child rooms that belong to a zone. Only applicable for zones; returns empty for rooms.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Zone ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_1.SpacesResponseModel, 'Returns the list of child rooms'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "findChildren", null);
+__decorate([
+    (0, common_1.Get)(':id/parent'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-parent',
+        summary: 'Get parent zone of a room',
+        description: 'Retrieves the parent zone for a room. Returns null if the room has no parent zone. ' +
+            'Zones do not have parents.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Room ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_1.SpaceResponseModel, 'Returns the parent zone or null'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "findParent", null);
+__decorate([
+    (0, common_1.Get)('intents/catalog'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-intent-catalog',
+        summary: 'Get intent catalog',
+        description: 'Retrieves the complete intent catalog with all available intent categories, intent types, ' +
+            'quick actions, and lighting roles. This provides metadata for building UI controls ' +
+            'and discovering available space control capabilities.',
+    }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.IntentCatalogResponseModel, 'Returns the intent catalog'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", spaces_response_model_2.IntentCatalogResponseModel)
+], SpacesDomainController.prototype, "getIntentCatalog", null);
+__decorate([
+    (0, common_1.Post)(':id/intents/lighting'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-lighting-intent',
+        summary: 'Execute lighting intent for space',
+        description: 'Executes a lighting intent command for all lights in the space. ' +
+            'Supports off, on, mode (work/relax/night), and brightness delta operations. ' +
+            'Commands are applied only to lighting devices with supported capabilities.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.LightingIntentResponseModel, 'Returns the intent execution result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Invalid intent data'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, lighting_intent_dto_1.ReqLightingIntentDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "executeLightingIntent", null);
+__decorate([
+    (0, common_1.Get)(':id/climate'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-climate',
+        summary: 'Get climate state for space',
+        description: 'Retrieves the current climate state for a space, including temperature readings, ' +
+            'target setpoint, and information about available climate control capabilities.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.ClimateStateResponseModel, 'Returns the climate state'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getClimateState", null);
+__decorate([
+    (0, common_1.Post)(':id/intents/climate'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-climate-intent',
+        summary: 'Execute climate intent for space',
+        description: 'Executes a climate intent command for all primary climate devices (thermostats, heating units, air conditioners) in the space. ' +
+            'Supports setpoint delta (+/- adjustments), direct setpoint set, and mode changes (HEAT/COOL/AUTO/OFF). ' +
+            'Devices are filtered by their role (HEATING_ONLY, COOLING_ONLY, AUTO) and capability (presence of HEATER/COOLER channels). ' +
+            'The target setpoint is clamped to the intersection of all device limits (most restrictive range).',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.ClimateIntentResponseModel, 'Returns the intent execution result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Invalid intent data'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, climate_intent_dto_1.ReqClimateIntentDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "executeClimateIntent", null);
+__decorate([
+    (0, common_1.Get)(':id/lighting/state'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-lighting-state',
+        summary: 'Get aggregated lighting state for space',
+        description: 'Retrieves the aggregated lighting state for a space, including per-role state (on/off, brightness, mixed status), ' +
+            'mode detection (which lighting mode current state matches), and summary statistics. ' +
+            'This endpoint provides pre-calculated values for UI display without panel-side calculation.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.LightingStateResponseModel, 'Returns the aggregated lighting state'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getLightingState", null);
+__decorate([
+    (0, common_1.Get)(':id/lighting/targets'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-lighting-targets',
+        summary: 'List light targets in space',
+        description: 'Retrieves all controllable light targets (device/channel pairs) in a space ' +
+            'along with their current role assignments and capabilities.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.LightTargetsResponseModel, 'Returns the list of light targets with role assignments'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getLightTargets", null);
+__decorate([
+    (0, common_1.Post)(':id/lighting/roles'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-lighting-role',
+        summary: 'Set lighting role for a light target',
+        description: 'Sets or updates the lighting role for a specific device/channel in a space. ' + 'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.LightingRoleResponseModel, 'Returns the created/updated lighting role assignment'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid role data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Role assignment validation failed'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, lighting_role_dto_1.ReqSetLightingRoleDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "setLightingRole", null);
+__decorate([
+    (0, common_1.Post)(':id/lighting/roles/bulk'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-lighting-roles-bulk',
+        summary: 'Bulk set lighting roles for light targets',
+        description: 'Sets or updates lighting roles for multiple device/channels in a space in a single operation. ' +
+            'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.BulkLightingRolesResponseModel, 'Returns the bulk update result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid role data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Role assignment validation failed'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, lighting_role_dto_1.ReqBulkSetLightingRolesDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "bulkSetLightingRoles", null);
+__decorate([
+    (0, common_1.Post)(':id/lighting/roles/defaults'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-lighting-roles-defaults',
+        summary: 'Apply default lighting roles',
+        description: 'Infers and applies default lighting roles for all lights in the space. ' +
+            'First light becomes MAIN, remaining lights become AMBIENT. Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.BulkLightingRolesResponseModel, 'Returns the bulk update result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "applyDefaultLightingRoles", null);
+__decorate([
+    (0, common_1.Delete)(':id/lighting/roles/:deviceId/:channelId'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'delete-spaces-module-space-lighting-role',
+        summary: 'Delete lighting role assignment',
+        description: 'Removes the lighting role assignment for a specific device/channel in a space. ' +
+            'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({ name: 'deviceId', type: 'string', format: 'uuid', description: 'Device ID' }),
+    (0, swagger_1.ApiParam)({ name: 'channelId', type: 'string', format: 'uuid', description: 'Channel ID' }),
+    (0, swagger_1.ApiNoContentResponse)({ description: 'Lighting role deleted successfully' }),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, common_1.HttpCode)(204),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('deviceId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(2, (0, common_1.Param)('channelId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "deleteLightingRole", null);
+__decorate([
+    (0, common_1.Get)(':id/climate/targets'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-climate-targets',
+        summary: 'List climate targets in space',
+        description: 'Retrieves all controllable climate devices in a space ' +
+            'along with their current role assignments and capabilities.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.ClimateTargetsResponseModel, 'Returns the list of climate devices with role assignments'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getClimateTargets", null);
+__decorate([
+    (0, common_1.Post)(':id/climate/roles'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-climate-role',
+        summary: 'Set or remove climate role for a climate device',
+        description: 'Sets, updates, or removes the climate role for a specific device in a space. ' +
+            'Omit the role field or set it to null to remove an existing role assignment. ' +
+            'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.ClimateRoleResponseModel, 'Returns the created/updated climate role assignment, or null if removed'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid role data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Role assignment validation failed'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, climate_role_dto_1.ReqSetClimateRoleDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "setClimateRole", null);
+__decorate([
+    (0, common_1.Post)(':id/climate/roles/bulk'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-climate-roles-bulk',
+        summary: 'Bulk set climate roles for climate devices',
+        description: 'Sets or updates climate roles for multiple devices in a space in a single operation. ' +
+            'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.BulkClimateRolesResponseModel, 'Returns the bulk update result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid role data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Role assignment validation failed'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, climate_role_dto_1.ReqBulkSetClimateRolesDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "bulkSetClimateRoles", null);
+__decorate([
+    (0, common_1.Post)(':id/climate/roles/defaults'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-climate-roles-defaults',
+        summary: 'Apply default climate roles',
+        description: 'Infers and applies default climate roles for all climate devices in the space. ' +
+            'Thermostats become PRIMARY, heaters/AC become AUXILIARY, fans become VENTILATION, ' +
+            'humidifiers/dehumidifiers become HUMIDITY. Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.BulkClimateRolesResponseModel, 'Returns the bulk update result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "applyDefaultClimateRoles", null);
+__decorate([
+    (0, common_1.Delete)(':id/climate/roles/:deviceId'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'delete-spaces-module-space-climate-role',
+        summary: 'Delete climate role assignment',
+        description: 'Removes the climate role assignment for a specific device in a space. ' +
+            'For actuator roles (PRIMARY, AUXILIARY, etc.), only deviceId is needed. ' +
+            'For sensor roles (TEMPERATURE_SENSOR, HUMIDITY_SENSOR), channelId query parameter must be provided. ' +
+            'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({ name: 'deviceId', type: 'string', format: 'uuid', description: 'Device ID' }),
+    (0, swagger_1.ApiQuery)({
+        name: 'channelId',
+        type: 'string',
+        format: 'uuid',
+        required: false,
+        description: 'Channel ID (required for sensor roles, omit for actuator roles)',
+    }),
+    (0, swagger_1.ApiNoContentResponse)({ description: 'Climate role deleted successfully' }),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, common_1.HttpCode)(204),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('deviceId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(2, (0, common_1.Query)('channelId', new common_1.ParseUUIDPipe({ version: '4', optional: true }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "deleteClimateRole", null);
+__decorate([
+    (0, common_1.Get)(':id/covers'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-covers',
+        summary: 'Get covers state for space',
+        description: 'Retrieves the current covers state for a space, including average position, ' +
+            'open/closed status, and device counts by role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.CoversStateResponseModel, 'Returns the covers state'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getCoversState", null);
+__decorate([
+    (0, common_1.Post)(':id/intents/covers'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-covers-intent',
+        summary: 'Execute covers intent for space',
+        description: 'Executes a covers intent command for all window coverings in the space. ' +
+            'Supports open, close, set_position, position_delta, role_position, and set_mode operations. ' +
+            'Commands are applied based on device capabilities and role assignments.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.CoversIntentResponseModel, 'Returns the intent execution result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Invalid intent data'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, covers_intent_dto_1.ReqCoversIntentDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "executeCoversIntent", null);
+__decorate([
+    (0, common_1.Get)(':id/covers/targets'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-covers-targets',
+        summary: 'List covers targets in space',
+        description: 'Retrieves all controllable window covering targets (device/channel pairs) in a space ' +
+            'along with their current role assignments and capabilities.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.CoversTargetsResponseModel, 'Returns the list of covers targets with role assignments'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getCoversTargets", null);
+__decorate([
+    (0, common_1.Post)(':id/covers/roles'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-covers-role',
+        summary: 'Set covers role for a covers target',
+        description: 'Sets or updates the covers role for a specific device/channel in a space. ' + 'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.CoversRoleResponseModel, 'Returns the created/updated covers role assignment'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid role data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Role assignment validation failed'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, covers_role_dto_1.ReqSetCoversRoleDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "setCoversRole", null);
+__decorate([
+    (0, common_1.Post)(':id/covers/roles/bulk'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-covers-roles-bulk',
+        summary: 'Bulk set covers roles for covers targets',
+        description: 'Sets or updates covers roles for multiple device/channels in a space in a single operation. ' +
+            'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.BulkCoversRolesResponseModel, 'Returns the bulk update result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid role data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Role assignment validation failed'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, covers_role_dto_1.ReqBulkSetCoversRolesDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "bulkSetCoversRoles", null);
+__decorate([
+    (0, common_1.Post)(':id/covers/roles/defaults'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-covers-roles-defaults',
+        summary: 'Apply default covers roles',
+        description: 'Infers and applies default covers roles for all window coverings in the space. ' +
+            'First cover becomes PRIMARY, remaining covers are assigned based on type. Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.BulkCoversRolesResponseModel, 'Returns the bulk update result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "applyDefaultCoversRoles", null);
+__decorate([
+    (0, common_1.Delete)(':id/covers/roles/:deviceId/:channelId'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'delete-spaces-module-space-covers-role',
+        summary: 'Delete covers role assignment',
+        description: 'Removes the covers role assignment for a specific device/channel in a space. Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({ name: 'deviceId', type: 'string', format: 'uuid', description: 'Device ID' }),
+    (0, swagger_1.ApiParam)({ name: 'channelId', type: 'string', format: 'uuid', description: 'Channel ID' }),
+    (0, swagger_1.ApiNoContentResponse)({ description: 'Covers role deleted successfully' }),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, common_1.HttpCode)(204),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('deviceId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(2, (0, common_1.Param)('channelId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "deleteCoversRole", null);
+__decorate([
+    (0, common_1.Get)(':id/sensors'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-sensors',
+        summary: 'Get sensor state for space',
+        description: 'Retrieves the current sensor state for a space, including aggregated readings, ' +
+            'environment summary, safety alerts, motion/occupancy status, and readings grouped by role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.SensorStateResponseModel, 'Returns the sensor state'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getSensorState", null);
+__decorate([
+    (0, common_1.Get)(':id/sensors/targets'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-sensor-targets',
+        summary: 'Get sensor targets in space',
+        description: 'Retrieves all sensor channels in a space that can be assigned roles, ' +
+            'including their current role assignments.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.SensorTargetsResponseModel, 'Returns the list of sensor targets'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getSensorTargets", null);
+__decorate([
+    (0, common_1.Post)(':id/sensors/roles'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-sensor-role',
+        summary: 'Set sensor role for a sensor target',
+        description: 'Sets or updates the sensor role for a specific device/channel in a space. ' + 'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.SensorRoleResponseModel, 'Returns the created/updated sensor role assignment'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid role data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Role assignment validation failed'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, sensor_role_dto_1.ReqSetSensorRoleDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "setSensorRole", null);
+__decorate([
+    (0, common_1.Post)(':id/sensors/roles/bulk'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-sensor-roles-bulk',
+        summary: 'Bulk set sensor roles for sensor targets',
+        description: 'Sets or updates sensor roles for multiple device/channels in a space in a single operation. ' +
+            'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.BulkSensorRolesResponseModel, 'Returns the bulk update result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid role data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Role assignment validation failed'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, sensor_role_dto_1.ReqBulkSetSensorRolesDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "bulkSetSensorRoles", null);
+__decorate([
+    (0, common_1.Post)(':id/sensors/roles/defaults'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-sensor-roles-defaults',
+        summary: 'Apply default sensor roles',
+        description: 'Infers and applies default sensor roles for all sensor channels in the space ' +
+            'based on channel category (environment, safety, security, air quality, energy). ' +
+            'Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.BulkSensorRolesResponseModel, 'Returns the bulk update result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "applyDefaultSensorRoles", null);
+__decorate([
+    (0, common_1.Delete)(':id/sensors/roles/:deviceId/:channelId'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'delete-spaces-module-space-sensor-role',
+        summary: 'Delete sensor role assignment',
+        description: 'Removes the sensor role assignment for a specific device/channel in a space. Requires owner or admin role.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({ name: 'deviceId', type: 'string', format: 'uuid', description: 'Device ID' }),
+    (0, swagger_1.ApiParam)({ name: 'channelId', type: 'string', format: 'uuid', description: 'Channel ID' }),
+    (0, swagger_1.ApiNoContentResponse)({ description: 'Sensor role deleted successfully' }),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, common_1.HttpCode)(204),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('deviceId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(2, (0, common_1.Param)('channelId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "deleteSensorRole", null);
+__decorate([
+    (0, common_1.Get)(':id/media/endpoints'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-media-endpoints',
+        summary: 'List derived media endpoints for space',
+        description: 'Returns a derived read model of all media endpoints in a space. ' +
+            'Endpoints are computed on-the-fly from device capabilities and use deterministic IDs. ' +
+            'A single device may produce multiple endpoints (e.g., TV as display + audio_output + remote_target).',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(derived_media_endpoint_model_1.DerivedMediaEndpointsResponseModel, 'Returns derived media endpoints for the space'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getDerivedMediaEndpoints", null);
+__decorate([
+    (0, common_1.Get)(':id/suggestion'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-suggestion',
+        summary: 'Get suggestion for space',
+        description: 'Retrieves a single, non-intrusive suggestion for the space based on current time and lighting state. ' +
+            'Returns null if no suggestion is applicable or suggestions are disabled for this space. ' +
+            'Suggestions have a cooldown period to avoid repetition.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.SuggestionResponseModel, 'Returns the suggestion or null'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getSuggestion", null);
+__decorate([
+    (0, common_1.Post)(':id/suggestion/feedback'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-suggestion-feedback',
+        summary: 'Submit suggestion feedback',
+        description: 'Records user feedback for a suggestion (applied or dismissed). ' +
+            'If applied, the corresponding lighting intent is executed. ' +
+            'A cooldown is set to prevent the same suggestion from reappearing immediately.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.SuggestionFeedbackResponseModel, 'Returns the feedback result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid feedback data'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, suggestion_dto_1.ReqSuggestionFeedbackDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "submitSuggestionFeedback", null);
+__decorate([
+    (0, common_1.Get)(':id/context/snapshot'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-context-snapshot',
+        summary: 'Capture context snapshot for space',
+        description: 'Captures a complete context snapshot of the current state of a space, including ' +
+            'lighting state (on/off, brightness, color) for all lights and climate state ' +
+            '(current temperature, setpoint). Useful for undo functionality, scene saving, ' +
+            'and providing context for automation decisions.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.ContextSnapshotResponseModel, 'Returns the context snapshot'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "captureContextSnapshot", null);
+__decorate([
+    (0, common_1.Get)(':id/undo'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-undo-state',
+        summary: 'Get undo state for space',
+        description: 'Retrieves the current undo state for a space, indicating whether an undo action is available. ' +
+            'The undo entry expires after 5 minutes and only the most recent intent can be undone.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.UndoStateResponseModel, 'Returns the undo state'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getUndoState", null);
+__decorate([
+    (0, common_1.Post)(':id/intents/undo'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-undo',
+        summary: 'Undo the last intent for space',
+        description: 'Reverts the most recent lighting or climate intent by restoring device states to their ' +
+            'values before the intent was executed. Only the most recent intent can be undone, and ' +
+            'the undo entry expires after 5 minutes.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(spaces_response_model_2.UndoResultResponseModel, 'Returns the undo result'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "executeUndo", null);
+__decorate([
+    (0, common_1.Get)(':id/media/bindings'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-media-bindings',
+        summary: 'List media activity bindings for space',
+        description: 'Returns all media activity bindings for a space. ' +
+            'Each binding maps a predefined activity (watch, listen, gaming, background, off) ' +
+            'to concrete derived endpoint IDs.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_binding_model_1.MediaActivityBindingsResponseModel, 'Returns media activity bindings for the space'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getMediaActivityBindings", null);
+__decorate([
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, common_1.Post)(':id/media/bindings/apply-defaults'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-media-bindings-apply-defaults',
+        summary: 'Apply default activity bindings',
+        description: 'Creates missing activity bindings with heuristic defaults based on available endpoints. ' +
+            'Does not overwrite existing bindings. Returns the full set of bindings after applying defaults.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_binding_model_1.MediaActivityBindingsResponseModel, 'Default bindings applied successfully'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "applyDefaultMediaActivityBindings", null);
+__decorate([
+    (0, common_1.Get)(':id/media/bindings/validate'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-media-bindings-validate',
+        summary: 'Validate media activity bindings',
+        description: 'Returns a diagnostic report for all activity bindings in a space. ' +
+            'Reports missing slots, invalid endpoints, type mismatches, and override issues.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_binding_model_1.BindingValidationResponseModel, 'Binding validation report'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "validateMediaActivityBindings", null);
+__decorate([
+    (0, common_1.Get)(':id/media/bindings/:bindingId'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-media-binding',
+        summary: 'Get a single media activity binding',
+        description: 'Returns a single media activity binding by ID.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({ name: 'bindingId', type: 'string', format: 'uuid', description: 'Binding ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_binding_model_1.MediaActivityBindingResponseModel, 'Returns the media activity binding'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space or binding not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('bindingId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getMediaActivityBinding", null);
+__decorate([
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, common_1.Post)(':id/media/bindings'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'create-spaces-module-space-media-binding',
+        summary: 'Create a media activity binding',
+        description: 'Creates a new media activity binding for a space. ' +
+            'Validates that referenced endpoint IDs exist and match the expected slot types. ' +
+            'Only one binding per activity key is allowed per space.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiCreatedSuccessResponse)(media_activity_binding_model_1.MediaActivityBindingResponseModel, 'Binding created successfully'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid binding data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Validation failed (endpoint not found, type mismatch, etc.)'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, media_activity_binding_dto_1.ReqCreateMediaActivityBindingDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "createMediaActivityBinding", null);
+__decorate([
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, common_1.Patch)(':id/media/bindings/:bindingId'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'update-spaces-module-space-media-binding',
+        summary: 'Update a media activity binding',
+        description: 'Updates an existing media activity binding. ' +
+            'Validates endpoint IDs and overrides against current derived endpoints.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({ name: 'bindingId', type: 'string', format: 'uuid', description: 'Binding ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_binding_model_1.MediaActivityBindingResponseModel, 'Binding updated successfully'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid binding data'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Validation failed'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space or binding not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('bindingId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, media_activity_binding_dto_1.ReqUpdateMediaActivityBindingDto]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "updateMediaActivityBinding", null);
+__decorate([
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, common_1.Delete)(':id/media/bindings/:bindingId'),
+    (0, common_1.HttpCode)(204),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'delete-spaces-module-space-media-binding',
+        summary: 'Delete a media activity binding',
+        description: 'Deletes a media activity binding.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({ name: 'bindingId', type: 'string', format: 'uuid', description: 'Binding ID' }),
+    (0, swagger_1.ApiNoContentResponse)({ description: 'Binding deleted successfully' }),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space or binding not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('bindingId', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "deleteMediaActivityBinding", null);
+__decorate([
+    (0, common_1.Get)(':id/media/activities/active'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'get-spaces-module-space-active-media-activity',
+        summary: 'Get active media activity',
+        description: 'Returns the currently active media activity for a space, or null if no activity is active.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_model_1.ActiveMediaActivityResponseModel, 'Active media activity state'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "getActiveMediaActivity", null);
+__decorate([
+    (0, common_1.Post)(':id/media/activities/:activityKey/preview'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'preview-spaces-module-space-media-activity',
+        summary: 'Preview a media activity execution plan (dry-run)',
+        description: 'Returns the resolved execution plan for a media activity without executing any commands, ' +
+            'changing state, or emitting WebSocket events. Useful for debugging bindings and endpoints.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({
+        name: 'activityKey',
+        type: 'string',
+        enum: Object.values(spaces_home_control_constants_1.MediaActivityKey),
+        description: 'Activity key to preview',
+    }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_model_1.MediaActivityDryRunPreviewResponseModel, 'Dry-run execution plan preview'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid activity key'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Binding missing or validation failed'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('activityKey')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "previewMediaActivity", null);
+__decorate([
+    (0, common_1.Post)(':id/media/activities/:activityKey/activate'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'activate-spaces-module-space-media-activity',
+        summary: 'Activate a media activity',
+        description: 'Activates a media activity for a space. Resolves the binding into an execution plan, ' +
+            'executes device commands (power, input, volume), and persists the active state.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, swagger_1.ApiParam)({
+        name: 'activityKey',
+        type: 'string',
+        enum: Object.values(spaces_home_control_constants_1.MediaActivityKey),
+        description: 'Activity key to activate',
+    }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_model_1.MediaActivityActivationResponseModel, 'Activity activation result'),
+    (0, api_documentation_decorator_1.ApiBadRequestResponse)('Invalid activity key'),
+    (0, api_documentation_decorator_1.ApiUnprocessableEntityResponse)('Binding missing or validation failed'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __param(1, (0, common_1.Param)('activityKey')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "activateMediaActivity", null);
+__decorate([
+    (0, common_1.Post)(':id/media/activities/deactivate'),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'deactivate-spaces-module-space-media-activity',
+        summary: 'Deactivate media activity',
+        description: 'Deactivates the current media activity for a space, resetting the active state.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'id', type: 'string', format: 'uuid', description: 'Space ID' }),
+    (0, api_documentation_decorator_1.ApiSuccessResponse)(media_activity_model_1.MediaActivityActivationResponseModel, 'Activity deactivated'),
+    (0, api_documentation_decorator_1.ApiNotFoundResponse)('Space not found'),
+    __param(0, (0, common_1.Param)('id', new common_1.ParseUUIDPipe({ version: '4' }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "deactivateMediaActivity", null);
+__decorate([
+    (0, common_1.Post)('suggestions/heartbeat'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, common_1.HttpCode)(200),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'trigger-spaces-module-suggestion-heartbeat',
+        summary: 'Trigger suggestion heartbeat (debug)',
+        description: 'Manually runs the space suggestion heartbeat cycle. Evaluates all enabled spaces and emits suggestion events via WebSocket.',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "triggerSuggestionHeartbeat", null);
+__decorate([
+    (0, common_1.Post)('suggestions/test'),
+    (0, roles_guard_1.Roles)(users_constants_1.UserRole.OWNER, users_constants_1.UserRole.ADMIN),
+    (0, common_1.HttpCode)(200),
+    (0, swagger_1.ApiOperation)({
+        operationId: 'trigger-spaces-module-suggestion-test',
+        summary: 'Emit a fake suggestion (debug)',
+        description: 'Emits a fake lighting suggestion via WebSocket, bypassing all rules and cooldowns. ' +
+            'Optionally specify a space_id in the request body to target a specific space.',
+    }),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SpacesDomainController.prototype, "emitTestSuggestion", null);
+exports.SpacesDomainController = SpacesDomainController = __decorate([
+    (0, swagger_1.ApiTags)(spaces_home_control_constants_2.SPACES_HOME_CONTROL_PLUGIN_API_TAG_NAME),
+    (0, swagger_1.ApiExtraModels)(spaces_response_model_2.LightingStateResponseModel, spaces_response_model_2.LightingStateDataModel, spaces_response_model_2.RolesStateMapDataModel, spaces_response_model_2.RoleAggregatedStateDataModel, spaces_response_model_2.RoleLastIntentDataModel, spaces_response_model_2.OtherLightsStateDataModel, spaces_response_model_2.SensorStateResponseModel, spaces_response_model_2.SensorStateDataModel, spaces_response_model_2.SensorAdditionalReadingDataModel, spaces_response_model_2.SensorReadingDataModel, spaces_response_model_2.SensorRoleReadingsDataModel, spaces_response_model_2.EnvironmentSummaryDataModel, spaces_response_model_2.SafetyAlertDataModel, spaces_response_model_2.SensorTargetsResponseModel, spaces_response_model_2.SensorTargetDataModel, spaces_response_model_2.SensorRoleResponseModel, spaces_response_model_2.BulkSensorRolesResponseModel, spaces_response_model_2.BulkSensorRolesResultDataModel, spaces_response_model_2.BulkSensorRoleResultItemModel, media_activity_binding_model_1.BindingValidationResponseModel, media_activity_binding_model_1.BindingValidationReportModel, media_activity_binding_model_1.BindingValidationIssueModel, media_activity_model_1.MediaActivityDryRunPreviewResponseModel, media_activity_model_1.MediaActivityDryRunPreviewModel, media_activity_model_1.MediaActivityDryRunWarningModel),
+    (0, common_1.Controller)('spaces'),
+    __metadata("design:paramtypes", [spaces_service_1.SpacesService,
+        home_control_spaces_service_1.HomeControlSpacesService,
+        space_intent_service_1.SpaceIntentService,
+        space_lighting_role_service_1.SpaceLightingRoleService,
+        space_lighting_state_service_1.SpaceLightingStateService,
+        space_climate_role_service_1.SpaceClimateRoleService,
+        space_covers_role_service_1.SpaceCoversRoleService,
+        space_sensor_role_service_1.SpaceSensorRoleService,
+        space_sensor_state_service_1.SpaceSensorStateService,
+        space_suggestion_service_1.SpaceSuggestionService,
+        space_suggestion_heartbeat_service_1.SpaceSuggestionHeartbeatService,
+        space_context_snapshot_service_1.SpaceContextSnapshotService,
+        space_undo_history_service_1.SpaceUndoHistoryService,
+        spec_1.IntentSpecLoaderService,
+        derived_media_endpoint_service_1.DerivedMediaEndpointService,
+        space_media_activity_binding_service_1.SpaceMediaActivityBindingService,
+        space_media_activity_service_1.SpaceMediaActivityService,
+        event_emitter_1.EventEmitter2])
+], SpacesDomainController);
+//# sourceMappingURL=spaces-domain.controller.js.map