@fastybird/smart-panel-backend 1.0.0-beta.3 → 1.1.0-alpha.0

package/dist/plugins/devices-homey/services/homey-mapping-preview.service.js

@@ -0,0 +1,999 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomeyMappingPreviewService = void 0;
+const common_1 = require("@nestjs/common");
+const devices_constants_1 = require("../../../modules/devices/devices.constants");
+const device_validation_service_1 = require("../../../modules/devices/services/device-validation.service");
+const property_command_value_utils_1 = require("../../../modules/devices/utils/property-command-value.utils");
+const schema_utils_1 = require("../../../modules/devices/utils/schema.utils");
+const homey_mapping_preview_error_1 = require("../errors/homey-mapping-preview.error");
+const mapping_loader_service_1 = require("../mappings/mapping-loader.service");
+const mapping_transformer_service_1 = require("../mappings/mapping-transformer.service");
+const homey_capability_model_1 = require("../models/homey-capability.model");
+const mapping_preview_model_1 = require("../models/mapping-preview.model");
+const homey_service_1 = require("./homey.service");
+const WARNING_SEVERITY_ORDER = {
+    [mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR]: 0,
+    [mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.WARNING]: 1,
+};
+const INTEGER_DATA_TYPES = new Set([
+    devices_constants_1.DataTypeType.CHAR,
+    devices_constants_1.DataTypeType.UCHAR,
+    devices_constants_1.DataTypeType.SHORT,
+    devices_constants_1.DataTypeType.USHORT,
+    devices_constants_1.DataTypeType.INT,
+    devices_constants_1.DataTypeType.UINT,
+]);
+const MAX_EXHAUSTIVE_NUMERIC_GRID_VALUES = 10_000;
+let HomeyMappingPreviewService = class HomeyMappingPreviewService {
+    constructor(homeyService, mappingLoader, mappingTransformer, deviceValidation) {
+        this.homeyService = homeyService;
+        this.mappingLoader = mappingLoader;
+        this.mappingTransformer = mappingTransformer;
+        this.deviceValidation = deviceValidation;
+    }
+    async generatePreview(request) {
+        let device;
+        try {
+            device = await this.homeyService.getFreshDevice(request.deviceId);
+        }
+        catch {
+            throw new homey_mapping_preview_error_1.HomeyMappingPreviewUnavailableError();
+        }
+        if (device === null) {
+            throw new homey_mapping_preview_error_1.HomeyMappingPreviewDeviceNotFoundError();
+        }
+        return this.createPreview(device, request.deviceCategory);
+    }
+    createPreview(device, requestedCategory) {
+        const deviceResolution = this.mappingLoader.resolveDeviceMappings(device);
+        const channelResolution = this.mappingLoader.resolveChannelMappings(device);
+        const propertyResolution = this.mappingLoader.resolvePropertyMappings(device);
+        const warnings = [];
+        this.addConflictWarnings(deviceResolution.conflicts, warnings);
+        this.addConflictWarnings(channelResolution.conflicts, warnings);
+        this.addConflictWarnings(propertyResolution.conflicts, warnings);
+        if (deviceResolution.mappings.length === 0 && deviceResolution.conflicts.length === 0) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.UNSUPPORTED_DEVICE, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.DEVICE, device.id, [], 'No device mapping supports this Homey device contract'));
+        }
+        if (channelResolution.mappings.length === 0 && channelResolution.conflicts.length === 0) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.NO_CHANNEL_MAPPING, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.DEVICE, device.id, [], 'No channel mappings are available for this Homey device'));
+        }
+        if (propertyResolution.mappings.length === 0 && propertyResolution.conflicts.length === 0) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.NO_PROPERTY_MAPPING, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.DEVICE, device.id, [], 'No property mappings are available for this Homey device'));
+        }
+        if (!device.available) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.DEVICE_UNAVAILABLE, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.WARNING, mapping_preview_model_1.HomeyMappingPreviewWarningScope.DEVICE, device.id, [], 'Homey currently reports this device as unavailable'));
+        }
+        const channels = this.createChannels(device, channelResolution, propertyResolution, warnings);
+        const recognizedCapabilityIds = new Set(propertyResolution.mappings.map((binding) => binding.capabilityId));
+        const unsupportedCapabilityIds = device.capabilities
+            .map((capability) => capability.id)
+            .filter((capabilityId) => !recognizedCapabilityIds.has(capabilityId))
+            .sort((left, right) => this.compareText(left, right));
+        for (const capabilityId of unsupportedCapabilityIds) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.UNSUPPORTED_CAPABILITY, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.WARNING, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CAPABILITY, capabilityId, [], 'This Homey capability has no resolved property mapping'));
+        }
+        const suggestedCategory = deviceResolution.mappings[0]?.deviceCategory ?? null;
+        const validCategories = deviceResolution.mappings.length === 0 ? [] : this.getValidCategories(channels);
+        const selectedCategory = requestedCategory ?? suggestedCategory;
+        if (selectedCategory !== null && !validCategories.includes(selectedCategory)) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.INVALID_DEVICE_CATEGORY, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.DEVICE, selectedCategory, [], 'The selected Smart Panel category is incompatible with the proposed channel structure'));
+        }
+        const preview = new mapping_preview_model_1.HomeyMappingPreviewModel();
+        preview.device = this.createDevice(device);
+        preview.suggestedCategory = suggestedCategory;
+        preview.selectedCategory = selectedCategory;
+        preview.validCategories = validCategories;
+        preview.channels = channels;
+        preview.unsupportedCapabilityIds = unsupportedCapabilityIds;
+        preview.warnings = warnings.sort((left, right) => this.compareWarnings(left, right));
+        preview.readyToAdopt =
+            selectedCategory !== null &&
+                channels.some((channel) => channel.properties.length > 0) &&
+                !preview.warnings.some((warning) => warning.severity === mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR);
+        return preview;
+    }
+    createDevice(device) {
+        const model = new mapping_preview_model_1.HomeyMappingPreviewDeviceModel();
+        model.id = device.id;
+        model.name = device.name;
+        model.class = device.class;
+        model.zoneId = device.zoneId;
+        model.zonePath = [...device.zonePath];
+        model.available = device.available;
+        return model;
+    }
+    createChannels(device, channelResolution, propertyResolution, warnings) {
+        const capabilities = new Map(device.capabilities.map((capability) => [capability.id, capability]));
+        const channels = [...channelResolution.mappings]
+            .sort((left, right) => this.compareText(left.channel.identifier, right.channel.identifier))
+            .map((mapping) => {
+            const channel = new mapping_preview_model_1.HomeyMappingPreviewChannelModel();
+            channel.identifier = mapping.channel.identifier;
+            channel.mappingName = mapping.name;
+            channel.mappingSource = mapping.source;
+            channel.category = mapping.channel.category;
+            channel.name = mapping.channel.name ?? this.humanize(mapping.channel.identifier);
+            channel.properties = [];
+            return channel;
+        });
+        const byIdentifier = new Map(channels.map((channel) => [channel.identifier, channel]));
+        for (const binding of [...propertyResolution.mappings].sort((left, right) => this.compareBindings(left, right))) {
+            const channelIdentifier = binding.mapping.property.channel;
+            const channel = byIdentifier.get(channelIdentifier);
+            if (!channel) {
+                warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.ORPHANED_PROPERTY_MAPPING, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CHANNEL, channelIdentifier, [binding.mapping.name], 'A resolved property mapping targets a channel that was not resolved'));
+                continue;
+            }
+            const capability = capabilities.get(binding.capabilityId);
+            if (!capability) {
+                continue;
+            }
+            channel.properties.push(this.createProperty(binding, capability, channel.category, warnings));
+        }
+        for (const channel of channels) {
+            channel.properties.sort((left, right) => this.compareText(left.capabilityId, right.capabilityId) ||
+                this.compareText(left.category, right.category) ||
+                this.compareText(left.mappingName, right.mappingName));
+        }
+        return channels;
+    }
+    createProperty(binding, capability, channelCategory, warnings) {
+        const { mapping } = binding;
+        const mappingCanRead = this.mappingCanRead(mapping.property.direction);
+        const mappingCanWrite = this.mappingCanWrite(mapping.property.direction);
+        const readable = mappingCanRead && capability.readable;
+        const writable = mappingCanWrite && capability.writable;
+        const effectiveRange = this.getEffectivePropertyRange(mapping, capability);
+        const conversion = this.createConversion(mapping, mapping.property.dataType, capability, mappingCanRead);
+        const property = new mapping_preview_model_1.HomeyMappingPreviewPropertyModel();
+        property.capabilityId = binding.capabilityId;
+        property.capabilityBaseId = binding.capabilityBaseId;
+        property.mappingName = mapping.name;
+        property.mappingSource = mapping.source;
+        property.category = mapping.property.category;
+        property.dataType = mapping.property.dataType;
+        property.direction = mapping.property.direction;
+        property.permissions = this.getPermissions(readable, writable);
+        property.readable = readable;
+        property.writable = writable;
+        property.unit = mapping.property.unit ?? capability.unit;
+        property.range = this.createRange(effectiveRange?.minimum ?? null, effectiveRange?.maximum ?? null, effectiveRange?.step ?? null);
+        property.sourceRange = this.createRange(capability.minimum, capability.maximum, capability.step);
+        property.enumValues = capability.enumValues.map((value) => value.id);
+        property.panelEnumValues = [];
+        property.currentValue = null;
+        property.valueAvailable = false;
+        property.capabilityAvailable = capability.available;
+        property.conversion = conversion;
+        if ((mappingCanRead && !capability.readable) || (mappingCanWrite && !capability.writable)) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.ACCESS_MISMATCH, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CAPABILITY, capability.id, [mapping.name], 'Homey capability access does not satisfy the resolved mapping direction'));
+        }
+        this.addCapabilityDomainWarning(mapping.property.transform, mapping.name, capability, mappingCanRead, warnings);
+        if (capability.available === false) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.CAPABILITY_UNAVAILABLE, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.WARNING, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CAPABILITY, capability.id, [mapping.name], 'Homey currently reports this capability as unavailable'));
+        }
+        if (readable) {
+            try {
+                property.currentValue = this.mappingTransformer.read(mapping, capability.value);
+                property.valueAvailable = property.currentValue !== null;
+                if (!property.valueAvailable) {
+                    warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.VALUE_UNAVAILABLE, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.WARNING, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CAPABILITY, capability.id, [mapping.name], 'No current transformed value is available for this capability'));
+                }
+            }
+            catch {
+                warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.VALUE_CONVERSION_FAILED, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CONVERSION, capability.id, [mapping.name], 'The current Homey value could not be converted by the resolved mapping'));
+            }
+        }
+        if (conversion.lossy) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.LOSSY_CONVERSION, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.WARNING, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CONVERSION, capability.id, [mapping.name], 'The resolved conversion can discard source precision or range information'));
+        }
+        if (conversion.ambiguous) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.AMBIGUOUS_CONVERSION, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.WARNING, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CONVERSION, capability.id, [mapping.name], 'The resolved conversion has more than one possible source representation'));
+        }
+        if (!conversion.reversible &&
+            ((conversion.type === mapping_preview_model_1.HomeyMappingConversionType.MAP && mapping.property.direction === 'bidirectional') ||
+                conversion.type === mapping_preview_model_1.HomeyMappingConversionType.BOOLEAN)) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.NON_REVERSIBLE_CONVERSION, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CONVERSION, capability.id, [mapping.name], 'The bidirectional map does not preserve values through a write and read round trip'));
+        }
+        const potentialPanelDomain = this.getPotentialPanelValues(mapping, capability, mappingCanRead, mappingCanWrite);
+        const potentialPanelValues = potentialPanelDomain.values;
+        if (effectiveRange?.minimum !== undefined) {
+            potentialPanelValues.push(effectiveRange.minimum);
+        }
+        if (effectiveRange?.maximum !== undefined) {
+            potentialPanelValues.push(effectiveRange.maximum);
+        }
+        if (property.valueAvailable) {
+            potentialPanelValues.push(property.currentValue);
+        }
+        property.panelEnumValues =
+            property.dataType === devices_constants_1.DataTypeType.ENUM
+                ? [...new Set(potentialPanelValues.filter((value) => typeof value === 'string'))]
+                : [];
+        if (!potentialPanelDomain.convertible ||
+            !this.isReadableDomainCompatible(mapping, capability, mappingCanRead, channelCategory, property.category, property.dataType, effectiveRange) ||
+            potentialPanelValues.some((value) => !this.isValidPanelValue(channelCategory, property.category, property.dataType, effectiveRange, value)) ||
+            this.hasIncompleteWritableEnumDomain(channelCategory, property.category, property.dataType, mapping.property.transform, mappingCanWrite)) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.INVALID_PROPERTY_VALUE_DOMAIN, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CONVERSION, capability.id, [mapping.name], 'The mapping value domain is incompatible with the Smart Panel property constraints'));
+        }
+        const potentialHomeyWriteDomain = this.getPotentialHomeyWriteValues(mapping, mappingCanWrite, channelCategory, property.category, property.dataType, effectiveRange);
+        if (!potentialHomeyWriteDomain.convertible ||
+            !this.isUnboundedPanelWriteDomainCompatible(mapping, capability, mappingCanWrite, channelCategory, property.category, property.dataType) ||
+            potentialHomeyWriteDomain.values.some((value) => !this.isValidHomeyValue(capability, value)) ||
+            !this.isWriteStrategyDomainCompatible(mapping, capability) ||
+            !this.isNumericWriteGridCompatible(mapping, capability, mappingCanWrite, channelCategory, property.category, property.dataType, effectiveRange)) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.INVALID_CAPABILITY_VALUE_DOMAIN, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CONVERSION, capability.id, [mapping.name], 'The write conversion can produce a value outside the declared Homey capability constraints'));
+        }
+        return property;
+    }
+    addCapabilityDomainWarning(transform, mappingName, capability, mappingCanRead, warnings) {
+        if (!mappingCanRead || transform?.type !== 'map') {
+            return;
+        }
+        const readTable = transform.read ?? {};
+        if (!this.isReadableMapDomainComplete(capability, readTable)) {
+            warnings.push(this.warning(mapping_preview_model_1.HomeyMappingPreviewWarningCode.INCOMPLETE_CAPABILITY_DOMAIN, mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR, mapping_preview_model_1.HomeyMappingPreviewWarningScope.CONVERSION, capability.id, [mappingName], 'The readable map does not cover every declared Homey capability value'));
+        }
+    }
+    isReadableMapDomainComplete(capability, readTable) {
+        if (capability.enumValues.length > 0) {
+            return capability.enumValues.every((value) => Object.hasOwn(readTable, value.id));
+        }
+        switch (capability.type) {
+            case homey_capability_model_1.HomeyCapabilityType.BOOLEAN:
+                return ['false', 'true'].every((value) => Object.hasOwn(readTable, value));
+            case homey_capability_model_1.HomeyCapabilityType.NUMBER:
+                return this.isNumericReadMapDomainComplete(capability, readTable);
+            case homey_capability_model_1.HomeyCapabilityType.STRING:
+            case homey_capability_model_1.HomeyCapabilityType.UNKNOWN:
+            case homey_capability_model_1.HomeyCapabilityType.ENUM:
+                return false;
+        }
+    }
+    isNumericReadMapDomainComplete(capability, readTable) {
+        if (capability.minimum === null ||
+            capability.maximum === null ||
+            capability.step === null ||
+            capability.step <= 0 ||
+            capability.maximum < capability.minimum) {
+            return false;
+        }
+        const quotient = (capability.maximum - capability.minimum) / capability.step;
+        const tolerance = Number.EPSILON * Math.max(1, Math.abs(quotient)) * 16;
+        const expectedValues = Math.floor(quotient + tolerance) + 1;
+        const coveredValues = new Set();
+        for (const key of Object.keys(readTable)) {
+            const numericValue = Number(key);
+            if (key.trim() === '' ||
+                !Number.isFinite(numericValue) ||
+                String(numericValue) !== key ||
+                numericValue < capability.minimum ||
+                numericValue > capability.maximum ||
+                !(0, property_command_value_utils_1.matchesStep)(numericValue, capability.step, capability.minimum)) {
+                continue;
+            }
+            coveredValues.add(numericValue);
+        }
+        return coveredValues.size === expectedValues;
+    }
+    getPotentialPanelValues(mapping, capability, mappingCanRead, mappingCanWrite) {
+        const transform = mapping.property.transform;
+        const values = [];
+        let convertible = true;
+        if (!transform) {
+            if (mappingCanRead) {
+                for (const sourceValue of this.getHomeyDomainValues(capability)) {
+                    try {
+                        values.push(this.mappingTransformer.read(mapping, sourceValue));
+                    }
+                    catch {
+                        convertible = false;
+                    }
+                }
+            }
+            else if (mappingCanWrite) {
+                values.push(...this.getHomeyDomainValues(capability));
+            }
+            return { values, convertible };
+        }
+        if (mappingCanRead) {
+            for (const sourceValue of this.getHomeyDomainValues(capability)) {
+                try {
+                    values.push(this.mappingTransformer.read(mapping, sourceValue));
+                }
+                catch {
+                    convertible = false;
+                }
+            }
+            switch (transform.type) {
+                case 'scale':
+                    values.push(...transform.output_range);
+                    break;
+                case 'map':
+                    values.push(...Object.values(transform.read ?? {}));
+                    break;
+                case 'boolean':
+                    values.push(false, true);
+                    break;
+                case 'clamp':
+                    values.push(transform.minimum, transform.maximum);
+                    break;
+                case 'constant':
+                    values.push(transform.value);
+                    break;
+                case 'threshold':
+                    values.push(transform.less_than_or_equal, transform.greater_than);
+                    break;
+                case 'thresholds':
+                    values.push(...transform.thresholds.map((entry) => entry.value), transform.default);
+                    break;
+                case 'round':
+                    break;
+            }
+        }
+        if (mappingCanWrite && transform.type === 'map') {
+            values.push(...Object.keys(transform.write ?? {}));
+        }
+        return { values, convertible };
+    }
+    isReadableDomainCompatible(mapping, capability, mappingCanRead, channelCategory, propertyCategory, dataType, mappingRange) {
+        if (!mappingCanRead) {
+            return true;
+        }
+        if (capability.type === homey_capability_model_1.HomeyCapabilityType.STRING) {
+            if (mapping.property.transform?.type === 'constant') {
+                return true;
+            }
+            return mapping.property.transform === undefined && dataType === devices_constants_1.DataTypeType.STRING;
+        }
+        if (capability.type === homey_capability_model_1.HomeyCapabilityType.UNKNOWN) {
+            return false;
+        }
+        if (capability.type === homey_capability_model_1.HomeyCapabilityType.ENUM && capability.enumValues.length === 0) {
+            return false;
+        }
+        if (capability.type !== homey_capability_model_1.HomeyCapabilityType.NUMBER) {
+            return true;
+        }
+        const capabilityGrid = {
+            base: capability.minimum ?? 0,
+            minimum: capability.minimum,
+            maximum: capability.maximum,
+            step: capability.step,
+        };
+        const exhaustiveValues = this.getExhaustiveGridValues(capabilityGrid);
+        if (exhaustiveValues !== null) {
+            return exhaustiveValues.every((value) => this.isValidTransformedPanelRead(mapping, channelCategory, propertyCategory, dataType, mappingRange, value));
+        }
+        const transform = mapping.property.transform;
+        if (transform?.type === 'constant' || transform?.type === 'threshold' || transform?.type === 'thresholds') {
+            return true;
+        }
+        if (transform?.type === 'map') {
+            return this.isReadableMapDomainComplete(capability, transform.read ?? {});
+        }
+        if (!this.isNumericDataType(dataType) || capability.minimum === null || capability.maximum === null) {
+            return false;
+        }
+        const panelGrid = this.getPanelNumericGrid(channelCategory, propertyCategory, dataType, mappingRange);
+        if (capability.step === null) {
+            if (transform?.type === 'boolean') {
+                return false;
+            }
+            if (dataType === devices_constants_1.DataTypeType.FLOAT) {
+                return panelGrid.step === null;
+            }
+            return INTEGER_DATA_TYPES.has(dataType) && (panelGrid.step === null || (0, property_command_value_utils_1.matchesStep)(1, panelGrid.step, 0));
+        }
+        if (capability.step <= 0 ||
+            transform?.type === 'clamp' ||
+            transform?.type === 'round' ||
+            transform?.type === 'boolean') {
+            return false;
+        }
+        const outputStep = (() => {
+            if (transform === undefined) {
+                return capability.step;
+            }
+            if (transform.type !== 'scale') {
+                return null;
+            }
+            const inputSpan = transform.input_range[1] - transform.input_range[0];
+            return inputSpan === 0
+                ? null
+                : Math.abs((capability.step * (transform.output_range[1] - transform.output_range[0])) / inputSpan);
+        })();
+        if (outputStep === null ||
+            !Number.isFinite(outputStep) ||
+            (INTEGER_DATA_TYPES.has(dataType) && !Number.isInteger(outputStep)) ||
+            !this.isValidTransformedPanelRead(mapping, channelCategory, propertyCategory, dataType, mappingRange, capability.minimum)) {
+            return false;
+        }
+        return panelGrid.step === null || (0, property_command_value_utils_1.matchesStep)(outputStep, panelGrid.step, 0);
+    }
+    isValidTransformedPanelRead(mapping, channelCategory, propertyCategory, dataType, mappingRange, homeyValue) {
+        try {
+            return this.isValidPanelValue(channelCategory, propertyCategory, dataType, mappingRange, this.mappingTransformer.read(mapping, homeyValue));
+        }
+        catch {
+            return false;
+        }
+    }
+    isUnboundedPanelWriteDomainCompatible(mapping, capability, mappingCanWrite, channelCategory, propertyCategory, dataType) {
+        if (!mappingCanWrite || (dataType !== devices_constants_1.DataTypeType.STRING && dataType !== devices_constants_1.DataTypeType.ENUM)) {
+            return true;
+        }
+        const metadata = (0, schema_utils_1.getPropertyMetadata)(channelCategory, propertyCategory);
+        const variant = metadata?.dataTypeVariants?.find((candidate) => candidate.data_type === dataType);
+        const format = variant ? variant.format : metadata?.format;
+        const hasFiniteEnumDomain = dataType === devices_constants_1.DataTypeType.ENUM &&
+            Array.isArray(format) &&
+            format.length > 0 &&
+            format.every((value) => typeof value === 'string');
+        if (hasFiniteEnumDomain) {
+            return true;
+        }
+        if (mapping.property.transform?.type === 'constant') {
+            return true;
+        }
+        return mapping.property.transform === undefined && capability.type === homey_capability_model_1.HomeyCapabilityType.STRING;
+    }
+    isValidPanelValue(channelCategory, propertyCategory, dataType, mappingRange, value) {
+        const metadata = (0, schema_utils_1.getPropertyMetadata)(channelCategory, propertyCategory);
+        if (metadata === null) {
+            return true;
+        }
+        const variant = metadata.dataTypeVariants?.find((candidate) => candidate.data_type === dataType);
+        const constraints = variant ?? metadata;
+        const invalid = typeof constraints.invalid === 'string' ||
+            typeof constraints.invalid === 'number' ||
+            typeof constraints.invalid === 'boolean'
+            ? constraints.invalid
+            : null;
+        const canonicalProperty = {
+            dataType,
+            format: constraints.format,
+            invalid,
+            step: constraints.step,
+        };
+        if (!(0, property_command_value_utils_1.validatePropertyCommandValue)(canonicalProperty, value).valid) {
+            return false;
+        }
+        if (mappingRange === undefined) {
+            return true;
+        }
+        const hasMappingBounds = mappingRange.minimum !== undefined || mappingRange.maximum !== undefined;
+        const mappingProperty = {
+            dataType,
+            format: hasMappingBounds
+                ? [mappingRange.minimum ?? null, mappingRange.maximum ?? null]
+                : constraints.format,
+            invalid,
+            step: mappingRange.step ?? constraints.step,
+        };
+        return (0, property_command_value_utils_1.validatePropertyCommandValue)(mappingProperty, value).valid;
+    }
+    getPotentialHomeyWriteValues(mapping, mappingCanWrite, channelCategory, propertyCategory, dataType, mappingRange) {
+        if (!mappingCanWrite) {
+            return { values: [], convertible: true };
+        }
+        const transform = mapping.property.transform;
+        const values = [];
+        let convertible = true;
+        for (const panelValue of this.getPanelDomainValues(channelCategory, propertyCategory, dataType, mappingRange)) {
+            if (!this.isValidPanelValue(channelCategory, propertyCategory, dataType, mappingRange, panelValue)) {
+                continue;
+            }
+            try {
+                values.push(this.mappingTransformer.write(mapping, panelValue));
+            }
+            catch {
+                convertible = false;
+            }
+        }
+        if (!transform) {
+            return { values, convertible };
+        }
+        switch (transform.type) {
+            case 'scale':
+                values.push(...transform.input_range);
+                break;
+            case 'map':
+                values.push(...Object.values(transform.write ?? {}));
+                break;
+            case 'boolean':
+                values.push(transform.true_value, transform.false_value);
+                break;
+            case 'clamp':
+                values.push(transform.minimum, transform.maximum);
+                break;
+            case 'constant':
+                values.push(transform.value);
+                break;
+            case 'threshold':
+                values.push(transform.less_than_or_equal, transform.greater_than);
+                break;
+            case 'thresholds':
+                values.push(...transform.thresholds.map((entry) => entry.value), transform.default);
+                break;
+            case 'round':
+                break;
+        }
+        return { values, convertible };
+    }
+    getHomeyDomainValues(capability) {
+        switch (capability.type) {
+            case homey_capability_model_1.HomeyCapabilityType.BOOLEAN:
+                return [false, true];
+            case homey_capability_model_1.HomeyCapabilityType.ENUM:
+                return capability.enumValues.map((value) => value.id);
+            case homey_capability_model_1.HomeyCapabilityType.NUMBER:
+                return [capability.minimum, capability.maximum].filter((value) => value !== null);
+            case homey_capability_model_1.HomeyCapabilityType.STRING:
+            case homey_capability_model_1.HomeyCapabilityType.UNKNOWN:
+                return [];
+        }
+    }
+    getPanelDomainValues(channelCategory, propertyCategory, dataType, mappingRange) {
+        const metadata = (0, schema_utils_1.getPropertyMetadata)(channelCategory, propertyCategory);
+        const variant = metadata?.dataTypeVariants?.find((candidate) => candidate.data_type === dataType);
+        const format = variant ? variant.format : metadata?.format;
+        const values = [];
+        if (dataType === devices_constants_1.DataTypeType.BOOL) {
+            values.push(false, true);
+        }
+        else if (dataType === devices_constants_1.DataTypeType.ENUM && Array.isArray(format)) {
+            values.push(...format.filter((value) => typeof value === 'string'));
+        }
+        else if (this.isNumericDataType(dataType)) {
+            const canonicalMinimum = Array.isArray(format) && typeof format[0] === 'number' ? format[0] : null;
+            const canonicalMaximum = Array.isArray(format) && typeof format[1] === 'number' ? format[1] : null;
+            const minimumCandidates = [canonicalMinimum, mappingRange?.minimum ?? null].filter((value) => value !== null);
+            const maximumCandidates = [canonicalMaximum, mappingRange?.maximum ?? null].filter((value) => value !== null);
+            if (minimumCandidates.length > 0) {
+                values.push(Math.max(...minimumCandidates));
+            }
+            if (maximumCandidates.length > 0) {
+                values.push(Math.min(...maximumCandidates));
+            }
+        }
+        return values;
+    }
+    isNumericDataType(dataType) {
+        return [
+            devices_constants_1.DataTypeType.CHAR,
+            devices_constants_1.DataTypeType.UCHAR,
+            devices_constants_1.DataTypeType.SHORT,
+            devices_constants_1.DataTypeType.USHORT,
+            devices_constants_1.DataTypeType.INT,
+            devices_constants_1.DataTypeType.UINT,
+            devices_constants_1.DataTypeType.FLOAT,
+        ].includes(dataType);
+    }
+    isValidHomeyValue(capability, value) {
+        switch (capability.type) {
+            case homey_capability_model_1.HomeyCapabilityType.BOOLEAN:
+                return typeof value === 'boolean';
+            case homey_capability_model_1.HomeyCapabilityType.ENUM:
+                return (typeof value === 'string' &&
+                    capability.enumValues.length > 0 &&
+                    capability.enumValues.some((candidate) => candidate.id === value));
+            case homey_capability_model_1.HomeyCapabilityType.STRING:
+                return typeof value === 'string';
+            case homey_capability_model_1.HomeyCapabilityType.NUMBER:
+                if (typeof value !== 'number' || !Number.isFinite(value)) {
+                    return false;
+                }
+                if (capability.minimum !== null && value < capability.minimum) {
+                    return false;
+                }
+                if (capability.maximum !== null && value > capability.maximum) {
+                    return false;
+                }
+                return (capability.step === null ||
+                    (capability.step > 0 && (0, property_command_value_utils_1.matchesStep)(value, capability.step, capability.minimum ?? 0)));
+            case homey_capability_model_1.HomeyCapabilityType.UNKNOWN:
+                return false;
+        }
+    }
+    isNumericWriteGridCompatible(mapping, capability, mappingCanWrite, channelCategory, propertyCategory, dataType, mappingRange) {
+        if (!mappingCanWrite || capability.type !== homey_capability_model_1.HomeyCapabilityType.NUMBER || !this.isNumericDataType(dataType)) {
+            return true;
+        }
+        if (capability.step !== null && capability.step <= 0) {
+            return false;
+        }
+        const transform = mapping.property.transform;
+        const panelGrid = this.getPanelNumericGrid(channelCategory, propertyCategory, dataType, mappingRange);
+        const exhaustiveValues = this.getExhaustiveGridValues(panelGrid);
+        if (exhaustiveValues !== null) {
+            const validPanelValues = exhaustiveValues.filter((value) => this.isValidPanelValue(channelCategory, propertyCategory, dataType, mappingRange, value));
+            return (validPanelValues.length > 0 &&
+                validPanelValues.every((value) => this.isValidTransformedHomeyWrite(mapping, capability, value)));
+        }
+        if (transform?.type === 'constant' || transform?.type === 'threshold' || transform?.type === 'thresholds') {
+            return true;
+        }
+        if (capability.step === null) {
+            return transform?.type !== 'map' && transform?.type !== 'boolean';
+        }
+        if (panelGrid.step === null || !Number.isFinite(panelGrid.step) || panelGrid.step <= 0) {
+            return false;
+        }
+        switch (transform?.type) {
+            case undefined:
+                return (this.isValidTransformedHomeyWrite(mapping, capability, panelGrid.base) &&
+                    (0, property_command_value_utils_1.matchesStep)(panelGrid.step, capability.step, 0));
+            case 'scale': {
+                const panelSpan = transform.output_range[1] - transform.output_range[0];
+                if (panelSpan === 0 || !this.isValidTransformedHomeyWrite(mapping, capability, panelGrid.base)) {
+                    return false;
+                }
+                const transformedStep = Math.abs((panelGrid.step * (transform.input_range[1] - transform.input_range[0])) / panelSpan);
+                return Number.isFinite(transformedStep) && (0, property_command_value_utils_1.matchesStep)(transformedStep, capability.step, 0);
+            }
+            case 'clamp':
+                return this.isClampedGridCompatible(mapping, capability, panelGrid, transform.minimum, transform.maximum);
+            case 'round': {
+                const quantum = 10 ** -(transform.precision ?? 0);
+                return ((0, property_command_value_utils_1.matchesStep)(panelGrid.step, quantum, 0) &&
+                    this.isValidTransformedHomeyWrite(mapping, capability, panelGrid.base) &&
+                    (0, property_command_value_utils_1.matchesStep)(panelGrid.step, capability.step, 0));
+            }
+            case 'map':
+            case 'boolean':
+                return false;
+        }
+    }
+    getPanelNumericGrid(channelCategory, propertyCategory, dataType, mappingRange) {
+        const metadata = (0, schema_utils_1.getPropertyMetadata)(channelCategory, propertyCategory);
+        const variant = metadata?.dataTypeVariants?.find((candidate) => candidate.data_type === dataType);
+        const constraints = variant ?? metadata;
+        const format = constraints?.format;
+        const canonicalMinimum = Array.isArray(format) && typeof format[0] === 'number' ? format[0] : null;
+        const canonicalMaximum = Array.isArray(format) && typeof format[1] === 'number' ? format[1] : null;
+        const minimumCandidates = [canonicalMinimum, mappingRange?.minimum ?? null].filter((value) => value !== null);
+        const maximumCandidates = [canonicalMaximum, mappingRange?.maximum ?? null].filter((value) => value !== null);
+        const hasMappingBounds = mappingRange?.minimum !== undefined || mappingRange?.maximum !== undefined;
+        return {
+            base: mappingRange?.minimum ?? (hasMappingBounds ? 0 : (canonicalMinimum ?? 0)),
+            minimum: minimumCandidates.length > 0 ? Math.max(...minimumCandidates) : null,
+            maximum: maximumCandidates.length > 0 ? Math.min(...maximumCandidates) : null,
+            step: mappingRange?.step ?? constraints?.step ?? (INTEGER_DATA_TYPES.has(dataType) ? 1 : null),
+        };
+    }
+    getExhaustiveGridValues(grid) {
+        if (grid.minimum === null ||
+            grid.maximum === null ||
+            grid.maximum < grid.minimum ||
+            grid.step === null ||
+            !Number.isFinite(grid.step) ||
+            grid.step <= 0) {
+            return null;
+        }
+        const firstIndex = Math.ceil((grid.minimum - grid.base) / grid.step - Number.EPSILON * 16);
+        const firstValue = grid.base + firstIndex * grid.step;
+        const valueCount = Math.floor((grid.maximum - firstValue) / grid.step + Number.EPSILON * 16) + 1;
+        if (valueCount < 0 || valueCount > MAX_EXHAUSTIVE_NUMERIC_GRID_VALUES) {
+            return null;
+        }
+        return Array.from({ length: valueCount }, (_, index) => Number((firstValue + index * grid.step).toPrecision(15)));
+    }
+    isValidTransformedHomeyWrite(mapping, capability, panelValue) {
+        try {
+            return this.isValidHomeyValue(capability, this.mappingTransformer.write(mapping, panelValue));
+        }
+        catch {
+            return false;
+        }
+    }
+    isClampedGridCompatible(mapping, capability, grid, minimum, maximum) {
+        if (grid.step === null ||
+            capability.step === null ||
+            !(0, property_command_value_utils_1.matchesStep)(grid.step, capability.step, 0) ||
+            !this.isValidHomeyValue(capability, minimum) ||
+            !this.isValidHomeyValue(capability, maximum)) {
+            return false;
+        }
+        const firstInteriorIndex = Math.ceil((minimum - grid.base) / grid.step - Number.EPSILON * 16);
+        const firstInteriorValue = Number((grid.base + firstInteriorIndex * grid.step).toPrecision(15));
+        return firstInteriorValue > maximum || this.isValidTransformedHomeyWrite(mapping, capability, firstInteriorValue);
+    }
+    hasIncompleteWritableEnumDomain(channelCategory, propertyCategory, dataType, transform, mappingCanWrite) {
+        if (!mappingCanWrite || dataType !== devices_constants_1.DataTypeType.ENUM || transform?.type !== 'map') {
+            return false;
+        }
+        const metadata = (0, schema_utils_1.getPropertyMetadata)(channelCategory, propertyCategory);
+        const variant = metadata?.dataTypeVariants?.find((candidate) => candidate.data_type === dataType);
+        const format = variant ? variant.format : metadata?.format;
+        return (Array.isArray(format) &&
+            format.every((value) => typeof value === 'string') &&
+            format.some((value) => !Object.hasOwn(transform.write ?? {}, value)));
+    }
+    createConversion(mapping, dataType, capability, mappingCanRead) {
+        const transform = mapping.property.transform;
+        const conversion = new mapping_preview_model_1.HomeyMappingPreviewConversionModel();
+        conversion.type = (transform?.type ?? mapping_preview_model_1.HomeyMappingConversionType.IDENTITY);
+        conversion.reversible = true;
+        conversion.lossy = false;
+        conversion.ambiguous = false;
+        conversion.inputRange = null;
+        conversion.outputRange = null;
+        conversion.clamp = null;
+        conversion.minimum = null;
+        conversion.maximum = null;
+        conversion.precision = null;
+        conversion.readTableSize = null;
+        conversion.writeTableSize = null;
+        switch (transform?.type) {
+            case undefined:
+                break;
+            case 'scale':
+                conversion.inputRange = [...transform.input_range];
+                conversion.outputRange = [...transform.output_range];
+                conversion.clamp = transform.clamp === true;
+                conversion.lossy = conversion.clamp;
+                conversion.reversible = !conversion.lossy;
+                break;
+            case 'map': {
+                const readEntries = Object.entries(transform.read ?? {});
+                const writeEntries = Object.entries(transform.write ?? {});
+                const readOutputs = readEntries.map(([, value]) => String(value));
+                conversion.readTableSize = readEntries.length;
+                conversion.writeTableSize = writeEntries.length;
+                conversion.ambiguous = new Set(readOutputs).size !== readOutputs.length;
+                conversion.lossy = conversion.ambiguous;
+                conversion.reversible =
+                    readEntries.length > 0 &&
+                        writeEntries.length > 0 &&
+                        readEntries.every(([source, target]) => String(transform.write?.[String(target)]) === source) &&
+                        writeEntries.every(([target, source]) => String(transform.read?.[String(source)]) === target);
+                break;
+            }
+            case 'boolean': {
+                const representationsEqual = transform.true_value === transform.false_value;
+                conversion.reversible = !representationsEqual;
+                conversion.lossy = representationsEqual;
+                conversion.ambiguous = representationsEqual;
+                break;
+            }
+            case 'clamp':
+                conversion.minimum = transform.minimum;
+                conversion.maximum = transform.maximum;
+                conversion.lossy = true;
+                conversion.reversible = false;
+                break;
+            case 'round':
+                conversion.precision = transform.precision ?? 0;
+                conversion.lossy = true;
+                conversion.reversible = false;
+                break;
+            case 'constant':
+            case 'threshold':
+            case 'thresholds':
+                conversion.lossy = true;
+                conversion.reversible = false;
+                break;
+        }
+        if (this.integerNormalizationCanLoseValues(transform, dataType, capability, mappingCanRead)) {
+            conversion.lossy = true;
+            conversion.reversible = false;
+        }
+        if (mapping.property.writeStrategy !== undefined) {
+            conversion.reversible = true;
+            conversion.lossy = false;
+            conversion.ambiguous = false;
+        }
+        return conversion;
+    }
+    getEffectivePropertyRange(mapping, capability) {
+        const configured = mapping.property.range;
+        if (mapping.property.transform !== undefined || capability.type !== homey_capability_model_1.HomeyCapabilityType.NUMBER) {
+            return configured;
+        }
+        const minimumCandidates = [configured?.minimum, capability.minimum].filter((value) => value !== undefined && value !== null);
+        const maximumCandidates = [configured?.maximum, capability.maximum].filter((value) => value !== undefined && value !== null);
+        const minimum = minimumCandidates.length > 0 ? Math.max(...minimumCandidates) : undefined;
+        const maximum = maximumCandidates.length > 0 ? Math.min(...maximumCandidates) : undefined;
+        const step = configured?.step ?? capability.step;
+        if (minimum === undefined && maximum === undefined && step === undefined) {
+            return undefined;
+        }
+        return { minimum, maximum, step };
+    }
+    isWriteStrategyDomainCompatible(mapping, capability) {
+        if (mapping.property.writeStrategy === undefined) {
+            return true;
+        }
+        const modes = new Set(capability.enumValues.map((value) => value.id));
+        const supportedModes = new Set(['off', 'heat', 'cool', 'auto', 'heat_cool']);
+        return (['off', 'heat', 'cool'].every((mode) => modes.has(mode)) &&
+            modes.has('auto') !== modes.has('heat_cool') &&
+            [...modes].every((mode) => supportedModes.has(mode)));
+    }
+    integerNormalizationCanLoseValues(transform, dataType, capability, mappingCanRead) {
+        if (!mappingCanRead || capability.type !== homey_capability_model_1.HomeyCapabilityType.NUMBER || !INTEGER_DATA_TYPES.has(dataType)) {
+            return false;
+        }
+        switch (transform?.type) {
+            case undefined:
+                return (capability.step === null || !Number.isInteger(capability.minimum ?? 0) || !Number.isInteger(capability.step));
+            case 'scale': {
+                if (transform.clamp === true || capability.step === null) {
+                    return true;
+                }
+                const inputSpan = transform.input_range[1] - transform.input_range[0];
+                if (inputSpan === 0) {
+                    return true;
+                }
+                const outputSpan = transform.output_range[1] - transform.output_range[0];
+                const sourceBase = capability.minimum ?? transform.input_range[0];
+                const outputBase = transform.output_range[0] + ((sourceBase - transform.input_range[0]) / inputSpan) * outputSpan;
+                const outputStep = (capability.step / inputSpan) * outputSpan;
+                return !Number.isInteger(outputBase) || !Number.isInteger(outputStep);
+            }
+            case 'map':
+                return Object.values(transform.read ?? {}).some((value) => typeof value !== 'number' || !Number.isInteger(value));
+            case 'boolean':
+            case 'clamp':
+            case 'round':
+            case 'constant':
+            case 'threshold':
+            case 'thresholds':
+                return false;
+        }
+    }
+    createRange(minimum, maximum, step) {
+        if (minimum === null && maximum === null && step === null) {
+            return null;
+        }
+        const range = new mapping_preview_model_1.HomeyMappingPreviewRangeModel();
+        range.minimum = minimum;
+        range.maximum = maximum;
+        range.step = step;
+        return range;
+    }
+    getPermissions(readable, writable) {
+        if (readable && writable) {
+            return [devices_constants_1.PermissionType.READ_WRITE];
+        }
+        if (readable) {
+            return [devices_constants_1.PermissionType.READ_ONLY];
+        }
+        if (writable) {
+            return [devices_constants_1.PermissionType.WRITE_ONLY];
+        }
+        return [];
+    }
+    mappingCanRead(direction) {
+        return direction === 'read_only' || direction === 'bidirectional';
+    }
+    mappingCanWrite(direction) {
+        return direction === 'write_only' || direction === 'bidirectional';
+    }
+    getValidCategories(channels) {
+        const validationChannels = this.createValidationChannels(channels);
+        return Object.values(devices_constants_1.DeviceCategory)
+            .filter((category) => this.deviceValidation.validateDeviceStructure({ category, channels: validationChannels }).isValid)
+            .sort((left, right) => this.compareText(left, right));
+    }
+    createValidationChannels(channels) {
+        return [
+            ...channels.map((channel) => ({
+                category: channel.category,
+                properties: channel.properties.map((property) => ({
+                    category: property.category,
+                    dataType: property.dataType,
+                    permissions: property.permissions,
+                })),
+            })),
+            {
+                category: devices_constants_1.ChannelCategory.DEVICE_INFORMATION,
+                properties: [
+                    {
+                        category: devices_constants_1.PropertyCategory.MANUFACTURER,
+                        dataType: devices_constants_1.DataTypeType.STRING,
+                        permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                    },
+                    {
+                        category: devices_constants_1.PropertyCategory.MODEL,
+                        dataType: devices_constants_1.DataTypeType.STRING,
+                        permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                    },
+                    {
+                        category: devices_constants_1.PropertyCategory.SERIAL_NUMBER,
+                        dataType: devices_constants_1.DataTypeType.STRING,
+                        permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                    },
+                    {
+                        category: devices_constants_1.PropertyCategory.FIRMWARE_REVISION,
+                        dataType: devices_constants_1.DataTypeType.STRING,
+                        permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                    },
+                    {
+                        category: devices_constants_1.PropertyCategory.HARDWARE_REVISION,
+                        dataType: devices_constants_1.DataTypeType.STRING,
+                        permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                    },
+                    {
+                        category: devices_constants_1.PropertyCategory.CONNECTION_TYPE,
+                        dataType: devices_constants_1.DataTypeType.ENUM,
+                        permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                    },
+                    {
+                        category: devices_constants_1.PropertyCategory.STATUS,
+                        dataType: devices_constants_1.DataTypeType.ENUM,
+                        permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                    },
+                ],
+            },
+        ];
+    }
+    addConflictWarnings(conflicts, warnings) {
+        for (const conflict of conflicts) {
+            const code = conflict.kind === 'devices'
+                ? mapping_preview_model_1.HomeyMappingPreviewWarningCode.DEVICE_MAPPING_CONFLICT
+                : conflict.kind === 'channels'
+                    ? mapping_preview_model_1.HomeyMappingPreviewWarningCode.CHANNEL_MAPPING_CONFLICT
+                    : mapping_preview_model_1.HomeyMappingPreviewWarningCode.PROPERTY_MAPPING_CONFLICT;
+            const scope = conflict.kind === 'properties'
+                ? mapping_preview_model_1.HomeyMappingPreviewWarningScope.CAPABILITY
+                : conflict.kind === 'channels'
+                    ? mapping_preview_model_1.HomeyMappingPreviewWarningScope.CHANNEL
+                    : mapping_preview_model_1.HomeyMappingPreviewWarningScope.DEVICE;
+            warnings.push(this.warning(code, conflict.policy === 'error'
+                ? mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.ERROR
+                : mapping_preview_model_1.HomeyMappingPreviewWarningSeverity.WARNING, scope, conflict.key, [...conflict.mappings].sort((left, right) => this.compareText(left, right)), `Multiple ${conflict.kind} mapping descriptors have equal priority`));
+        }
+    }
+    warning(code, severity, scope, identifier, mappingNames, message) {
+        const warning = new mapping_preview_model_1.HomeyMappingPreviewWarningModel();
+        warning.code = code;
+        warning.severity = severity;
+        warning.scope = scope;
+        warning.identifier = identifier;
+        warning.mappingNames = mappingNames;
+        warning.message = message;
+        return warning;
+    }
+    compareBindings(left, right) {
+        return (this.compareText(left.mapping.property.channel, right.mapping.property.channel) ||
+            this.compareText(left.capabilityId, right.capabilityId) ||
+            this.compareText(left.mapping.property.category, right.mapping.property.category) ||
+            this.compareText(left.mapping.name, right.mapping.name));
+    }
+    compareWarnings(left, right) {
+        return (WARNING_SEVERITY_ORDER[left.severity] - WARNING_SEVERITY_ORDER[right.severity] ||
+            this.compareText(left.code, right.code) ||
+            this.compareText(left.scope, right.scope) ||
+            this.compareText(left.identifier ?? '', right.identifier ?? '') ||
+            this.compareText(left.mappingNames.join('\u0000'), right.mappingNames.join('\u0000')));
+    }
+    humanize(identifier) {
+        const value = identifier.replace(/[-_]+/g, ' ').trim();
+        return value.length === 0 ? identifier : value[0].toUpperCase() + value.slice(1);
+    }
+    compareText(left, right) {
+        return left < right ? -1 : left > right ? 1 : 0;
+    }
+};
+exports.HomeyMappingPreviewService = HomeyMappingPreviewService;
+exports.HomeyMappingPreviewService = HomeyMappingPreviewService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [homey_service_1.HomeyService,
+        mapping_loader_service_1.HomeyMappingLoaderService,
+        mapping_transformer_service_1.HomeyMappingTransformerService,
+        device_validation_service_1.DeviceValidationService])
+], HomeyMappingPreviewService);
+//# sourceMappingURL=homey-mapping-preview.service.js.map